diff --git a/sched/sched_sq/los_sched.c b/sched/sched_sq/los_sched.c index dab0291..ed3f2ea 100644 --- a/sched/sched_sq/los_sched.c +++ b/sched/sched_sq/los_sched.c @@ -48,43 +48,46 @@ #include "los_stat_pri.h" #endif -#define OS_32BIT_MAX 0xFFFFFFFFUL -#define OS_SCHED_FIFO_TIMEOUT 0x7FFFFFFF -#define OS_PRIORITY_QUEUE_NUM 32 -#define PRIQUEUE_PRIOR0_BIT 0x80000000U -#define OS_SCHED_TIME_SLICES_MIN ((5000 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 5ms */ -#define OS_SCHED_TIME_SLICES_MAX ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) -#define OS_SCHED_TIME_SLICES_DIFF (OS_SCHED_TIME_SLICES_MAX - OS_SCHED_TIME_SLICES_MIN) -#define OS_SCHED_READY_MAX 30 -#define OS_TIME_SLICE_MIN (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */ - +#define OS_32BIT_MAX 0xFFFFFFFFUL //定义32位操作系统的最大值 +#define OS_SCHED_FIFO_TIMEOUT 0x7FFFFFFF //定义FIFO调度器的超时值 +#define OS_PRIORITY_QUEUE_NUM 32 //定义优先级队列的数量 +#define PRIQUEUE_PRIOR0_BIT 0x80000000U //定义优先级队列中优先级0的最高位 +#define OS_SCHED_TIME_SLICES_MIN ((5000 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 定义调度器的最小时间片(以纳秒为单位)5ms */ +#define OS_SCHED_TIME_SLICES_MAX ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) //定义调度器的最大时间片(以纳秒为单位) +#define OS_SCHED_TIME_SLICES_DIFF (OS_SCHED_TIME_SLICES_MAX - OS_SCHED_TIME_SLICES_MIN) //定义调度器最大时间片和最小时间片之间的差值 +#define OS_SCHED_READY_MAX 30 //定义调度器的最大就绪任务数 +#define OS_TIME_SLICE_MIN (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /*定义最小时间片(以INT32类型表示,单位为50微秒) 50us */ + +//定义调度器队列结构体SchedQueue typedef struct { - LOS_DL_LIST priQueueList[OS_PRIORITY_QUEUE_NUM]; - UINT32 readyTasks[OS_PRIORITY_QUEUE_NUM]; - UINT32 queueBitmap; + LOS_DL_LIST priQueueList[OS_PRIORITY_QUEUE_NUM]; // 优先级队列列表 + UINT32 readyTasks[OS_PRIORITY_QUEUE_NUM]; // 就绪任务数 + UINT32 queueBitmap; // 队列位图 } SchedQueue; - +//定义调度器结构体Sched typedef struct { - SchedQueue queueList[OS_PRIORITY_QUEUE_NUM]; - UINT32 queueBitmap; - SchedScan taskScan; - SchedScan swtmrScan; + SchedQueue queueList[OS_PRIORITY_QUEUE_NUM]; // 优先级队列列表 + UINT32 queueBitmap; // 队列位图 + SchedScan taskScan; // 任务扫描 + SchedScan swtmrScan; // 软件定时器扫描 } Sched; -STATIC Sched *g_sched = NULL; -STATIC UINT64 g_schedTickMaxResponseTime; -UINT64 g_sysSchedStartTime = OS_64BIT_MAX; +STATIC Sched *g_sched = NULL; //定义全局调度器变量g_sched +STATIC UINT64 g_schedTickMaxResponseTime; //定义调度器tick的最大响应时间 +UINT64 g_sysSchedStartTime = OS_64BIT_MAX; //定义系统调度器的起始时间 #ifdef LOSCFG_SCHED_TICK_DEBUG -#define OS_SCHED_DEBUG_DATA_NUM 1000 +#define OS_SCHED_DEBUG_DATA_NUM 1000 //定义调度器tick调试数据数量的常量 +//定义调度器tick调试数据结构体SchedTickDebug typedef struct { - UINT32 tickResporeTime[OS_SCHED_DEBUG_DATA_NUM]; - UINT32 index; - UINT32 setTickCount; - UINT64 oldResporeTime; + UINT32 tickResporeTime[OS_SCHED_DEBUG_DATA_NUM]; // tick响应时间数组 + UINT32 index; // 当前数据索引 + UINT32 setTickCount; // 设置的tick计数 + UINT64 oldResporeTime; // 上一次的响应时间 } SchedTickDebug; -STATIC SchedTickDebug *g_schedTickDebug = NULL; +STATIC SchedTickDebug *g_schedTickDebug = NULL; //定义全局调度器tick调试数据变量g_schedTickDebug +//初始化调度器tick调试数据 STATIC UINT32 OsSchedDebugInit(VOID) { UINT32 size = sizeof(SchedTickDebug) * LOSCFG_KERNEL_CORE_NUM; @@ -96,7 +99,7 @@ STATIC UINT32 OsSchedDebugInit(VOID) (VOID)memset_s(g_schedTickDebug, size, 0, size); return LOS_OK; } - +//记录调度器tick调试数据 VOID OsSchedDebugRecordData(VOID) { SchedTickDebug *schedDebug = &g_schedTickDebug[ArchCurrCpuid()]; @@ -107,265 +110,308 @@ VOID OsSchedDebugRecordData(VOID) schedDebug->index++; } } - +//获取调度器tick调试数据 SchedTickDebug *OsSchedDebugGet(VOID) { return g_schedTickDebug; } - +// 显示调度器 tick 响应时间的 Shell 命令函数 UINT32 OsShellShowTickRespo(VOID) { - UINT32 intSave; - UINT16 cpu; - UINT64 allTime; + UINT32 intSave; // 保存中断状态的变量 + UINT16 cpu; // CPU 编号 + UINT64 allTime; // 所有时间的总和 + // 计算存储调度器调试信息的内存大小 UINT32 tickSize = sizeof(SchedTickDebug) * LOSCFG_KERNEL_CORE_NUM; + + // 在系统内存池中分配存储调度器调试信息的内存 SchedTickDebug *schedDebug = (SchedTickDebug *)LOS_MemAlloc(m_aucSysMem1, tickSize); if (schedDebug == NULL) { return LOS_NOK; } + // 创建一个数组来保存每个 CPU 上的任务和软件定时器的排序链表节点数 UINT32 sortLinkNum[LOSCFG_KERNEL_CORE_NUM]; + + // 禁止调度器调度 SCHEDULER_LOCK(intSave); + + // 将调度器调试信息拷贝到 schedDebug 中 (VOID)memcpy_s((CHAR *)schedDebug, tickSize, (CHAR *)OsSchedDebugGet(), tickSize); + + // 将调度器调试信息清零 (VOID)memset_s((CHAR *)OsSchedDebugGet(), tickSize, 0, tickSize); + + // 计算每个 CPU 上的任务和软件定时器的排序链表节点数 for (cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) { sortLinkNum[cpu] = OsPercpuGetByID(cpu)->taskSortLink.nodeNum + OsPercpuGetByID(cpu)->swtmrSortLink.nodeNum; } + + // 允许调度器调度 SCHEDULER_UNLOCK(intSave); + // 遍历每个 CPU 上的调度器调试信息 for (cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) { - SchedTickDebug *schedData = &schedDebug[cpu]; + SchedTickDebug *schedData = &schedDebug[cpu]; // 获取当前 CPU 的调度器调试信息 + + // 打印当前 CPU 的调度器调试信息 PRINTK("cpu : %u sched data num : %u set time count : %u SortMax : %u\n", cpu, schedData->index, schedData->setTickCount, sortLinkNum[cpu]); - UINT32 *data = schedData->tickResporeTime; - allTime = 0; + + UINT32 *data = schedData->tickResporeTime; // 获取当前 CPU 的 tick 响应时间数据 + + allTime = 0; // 重置总时间 + + // 遍历 tick 响应时间数据 for (UINT32 i = 1; i < schedData->index; i++) { - allTime += data[i]; - UINT32 timeUs = (data[i] * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; - PRINTK(" %u(%u)", timeUs, timeUs / OS_US_PER_TICK); - if ((i != 0) && ((i % 5) == 0)) { /* A row of 5 data */ - PRINTK("\n"); + allTime += data[i]; // 计算总时间 + UINT32 timeUs = (data[i] * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将时间转换为微秒 + PRINTK(" %u(%u)", timeUs, timeUs / OS_US_PER_TICK); // 打印时间 + if ((i != 0) && ((i % 5) == 0)) { /* A row of 5 data每行显示5个数据 */ + PRINTK("\n"); // 换行 } } - allTime = (allTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; - PRINTK("\nTick Indicates the average response period: %llu(us)\n", allTime / (schedData->index - 1)); + allTime = (allTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将总时间转换为微秒 + PRINTK("\nTick Indicates the average response period: %llu(us)\n", allTime / (schedData->index - 1)); //平均响应周期 } + // 释放内存 (VOID)LOS_MemFree(m_aucSysMem1, schedDebug); + return LOS_OK; } #else - +//显示调度器tick响应时间的Shell命令函数 UINT32 OsShellShowTickRespo(VOID) { return LOS_NOK; } #endif - +//定义调度器调试开关 #ifdef LOSCFG_SCHED_DEBUG +// 显示调度器调度参数的 Shell 命令函数 UINT32 OsShellShowSchedParam(VOID) { - UINT64 averRunTime; - UINT64 averTimeSlice; - UINT64 averSchedWait; - UINT64 averPendTime; - UINT32 intSave; - UINT32 size = g_taskMaxNum * sizeof(LosTaskCB); - LosTaskCB *taskCBArray = LOS_MemAlloc(m_aucSysMem1, size); + UINT64 averRunTime; // 平均运行时间 + UINT64 averTimeSlice; // 平均时间片 + UINT64 averSchedWait; // 平均等待调度时间 + UINT64 averPendTime; // 平均挂起时间 + UINT32 intSave; // 保存中断状态的变量 + UINT32 size = g_taskMaxNum * sizeof(LosTaskCB); // 计算任务控制块数组的大小 + LosTaskCB *taskCBArray = LOS_MemAlloc(m_aucSysMem1, size); // 在系统内存池中分配任务控制块数组的内存 if (taskCBArray == NULL) { return LOS_NOK; } - SCHEDULER_LOCK(intSave); + SCHEDULER_LOCK(intSave); // 禁止调度器调度 + + // 将全局的任务控制块数组拷贝到局部数组中 (VOID)memcpy_s(taskCBArray, size, g_taskCBArray, size); - SCHEDULER_UNLOCK(intSave); + + SCHEDULER_UNLOCK(intSave); // 允许调度器调度 + + // 打印表头 PRINTK(" Tid AverRunTime(us) SwitchCount AverTimeSlice(us) TimeSliceCount AverReadyWait(us) " "AverPendTime(us) TaskName \n"); + + // 遍历任务控制块数组 for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) { - LosTaskCB *taskCB = taskCBArray + tid; + LosTaskCB *taskCB = taskCBArray + tid; // 获取当前任务控制块 + + // 如果任务控制块未使用,则跳过 if (OsTaskIsUnused(taskCB)) { continue; } - averRunTime = 0; - averTimeSlice = 0; - averPendTime = 0; - averSchedWait = 0; + averRunTime = 0; // 平均运行时间初始化为0 + averTimeSlice = 0; // 平均时间片初始化为0 + averPendTime = 0; // 平均挂起时间初始化为0 + averSchedWait = 0; // 平均等待调度时间初始化为0 + // 计算平均运行时间 if (taskCB->schedStat.switchCount >= 1) { - averRunTime = taskCB->schedStat.runTime / taskCB->schedStat.switchCount; - averRunTime = (averRunTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; + averRunTime = taskCB->schedStat.runTime / taskCB->schedStat.switchCount; // 平均运行时间 = 运行时间 / 切换次数 + averRunTime = (averRunTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将平均运行时间转换为微秒 } + // 计算平均时间片 if (taskCB->schedStat.timeSliceCount > 1) { - averTimeSlice = taskCB->schedStat.timeSliceTime / (taskCB->schedStat.timeSliceCount - 1); - averTimeSlice = (averTimeSlice * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; + averTimeSlice = taskCB->schedStat.timeSliceTime / (taskCB->schedStat.timeSliceCount - 1); // 平均时间片 = 时间片总数 / (时间片个数 - 1) + averTimeSlice = (averTimeSlice * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将平均时间片转换为微秒 } + // 计算平均挂起时间 if (taskCB->schedStat.pendCount > 1) { - averPendTime = taskCB->schedStat.pendTime / taskCB->schedStat.pendCount; - averPendTime = (averPendTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; + averPendTime = taskCB->schedStat.pendTime / taskCB->schedStat.pendCount; // 平均挂起时间 = 挂起时间 / 挂起次数 + averPendTime = (averPendTime * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将平均挂起时间转换为微秒 } + // 计算平均等待调度时间 if (taskCB->schedStat.waitSchedCount > 0) { - averSchedWait = taskCB->schedStat.waitSchedTime / taskCB->schedStat.waitSchedCount; - averSchedWait = (averSchedWait * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; + averSchedWait = taskCB->schedStat.waitSchedTime / taskCB->schedStat.waitSchedCount; // 平均等待调度时间 = 等待调度时间 / 等待调度次数 + averSchedWait = (averSchedWait * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US; // 将平均等待调度时间转换为微秒 } + // 打印任务的调度参数信息 PRINTK("%5u%19llu%15llu%19llu%18llu%19llu%18llu %-32s\n", taskCB->taskID, averRunTime, taskCB->schedStat.switchCount, averTimeSlice, taskCB->schedStat.timeSliceCount - 1, averSchedWait, averPendTime, taskCB->taskName); } - (VOID)LOS_MemFree(m_aucSysMem1, taskCBArray); + (VOID)LOS_MemFree(m_aucSysMem1, taskCBArray); // 释放内存 return LOS_OK; } #else + UINT32 OsShellShowSchedParam(VOID) { - return LOS_NOK; + return LOS_NOK; // 返回错误码,表示未实现该函数 } #endif +// 设置调度器的 tick 定时器类型 UINT32 OsSchedSetTickTimerType(UINT32 timerType) { switch (timerType) { - case 32: /* 32 bit timer */ - g_schedTickMaxResponseTime = OS_32BIT_MAX; + case 32: /* 32 位定时器 */ + g_schedTickMaxResponseTime = OS_32BIT_MAX; // 设置最大的 tick 响应时间为 32 位定时器的最大值 break; - case 64: /* 64 bit timer */ - g_schedTickMaxResponseTime = OS_64BIT_MAX; + case 64: /* 64 位定时器 */ + g_schedTickMaxResponseTime = OS_64BIT_MAX; // 设置最大的 tick 响应时间为 64 位定时器的最大值 break; default: PRINT_ERR("Unsupported Tick Timer type, The system only supports 32 and 64 bit tick timers\n"); - return LOS_NOK; + return LOS_NOK; // 返回错误码,表示不支持该类型的定时器 } - return LOS_OK; + return LOS_OK; // 返回成功码 } +// 设置调度器的启动时间 STATIC VOID OsSchedSetStartTime(UINT64 currCycle) { if (g_sysSchedStartTime == OS_64BIT_MAX) { - g_sysSchedStartTime = currCycle; + g_sysSchedStartTime = currCycle; // 如果系统的调度启动时间未设置,则设置为当前的时钟周期数 } } +// 更新时间片 STATIC INLINE VOID OsTimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime) { - LOS_ASSERT(currTime >= taskCB->startTime); + LOS_ASSERT(currTime >= taskCB->startTime); // 断言当前时间大于等于任务的启动时间 - INT32 incTime = (currTime - taskCB->startTime - taskCB->irqUsedTime); + INT32 incTime = (currTime - taskCB->startTime - taskCB->irqUsedTime); // 计算增加的时间 - LOS_ASSERT(incTime >= 0); + LOS_ASSERT(incTime >= 0); // 断言增加的时间大于等于0 if (taskCB->policy == LOS_SCHED_RR) { - taskCB->timeSlice -= incTime; + taskCB->timeSlice -= incTime; // 更新时间片剩余时间 #ifdef LOSCFG_SCHED_DEBUG - taskCB->schedStat.timeSliceRealTime += incTime; + taskCB->schedStat.timeSliceRealTime += incTime; // 更新调度统计信息中的实际时间片使用时间 #endif } - taskCB->irqUsedTime = 0; - taskCB->startTime = currTime; + taskCB->irqUsedTime = 0; // 清零中断使用的时间 + taskCB->startTime = currTime; // 更新任务的启动时间 #ifdef LOSCFG_SCHED_DEBUG - taskCB->schedStat.allRuntime += incTime; + taskCB->schedStat.allRuntime += incTime; // 更新调度统计信息中的总运行时间 #endif } +// 重新加载 tick 定时器 STATIC INLINE VOID OsSchedTickReload(Percpu *currCpu, UINT64 nextResponseTime, UINT32 responseID, BOOL isTimeSlice) { UINT64 currTime, nextExpireTime; UINT32 usedTime; - currTime = OsGetCurrSchedTimeCycle(); + currTime = OsGetCurrSchedTimeCycle(); // 获取当前的调度时间 if (currCpu->tickStartTime != 0) { - usedTime = currTime - currCpu->tickStartTime; - currCpu->tickStartTime = 0; + usedTime = currTime - currCpu->tickStartTime; // 计算 tick 定时器已经使用的时间 + currCpu->tickStartTime = 0; // 清零 tick 定时器的启动时间 } else { usedTime = 0; } if ((nextResponseTime > usedTime) && ((nextResponseTime - usedTime) > OS_TICK_RESPONSE_PRECISION)) { - nextResponseTime -= usedTime; + nextResponseTime -= usedTime; // 减去已经使用的时间,得到下一次 tick 定时器的响应时间 } else { - nextResponseTime = OS_TICK_RESPONSE_PRECISION; + nextResponseTime = OS_TICK_RESPONSE_PRECISION; // 如果计算出的响应时间小于精度要求,设置为精度要求 } - nextExpireTime = currTime + nextResponseTime; + nextExpireTime = currTime + nextResponseTime; // 计算下一次 tick 定时器的到期时间 if (nextExpireTime >= currCpu->responseTime) { - return; + return; // 如果下一次到期时间大于等于当前的响应时间,直接返回 } if (isTimeSlice) { - /* The expiration time of the current system is the thread's slice expiration time */ - currCpu->responseID = responseID; + /* 当前系统的到期时间是线程的时间片到期时间 */ + currCpu->responseID = responseID; // 设置当前 CPU 的响应 ID } else { - currCpu->responseID = OS_INVALID_VALUE; + currCpu->responseID = OS_INVALID_VALUE; // 设置当前 CPU 的响应 ID 为无效值 } - currCpu->responseTime = nextExpireTime; - HalClockTickTimerReload(nextResponseTime); + currCpu->responseTime = nextExpireTime; // 更新当前 CPU 的响应时间 + HalClockTickTimerReload(nextResponseTime); // 重新加载 tick 定时器 #ifdef LOSCFG_SCHED_TICK_DEBUG SchedTickDebug *schedDebug = &g_schedTickDebug[ArchCurrCpuid()]; if (schedDebug->index < OS_SCHED_DEBUG_DATA_NUM) { - schedDebug->setTickCount++; + schedDebug->setTickCount++; // 更新调度 tick 调试信息中的设置 tick 数量 } #endif } + STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, UINT32 oldResponseID) { - UINT64 nextExpireTime = OsGetNextExpireTime(startTime); - Percpu *currCpu = OsPercpuGet(); + UINT64 nextExpireTime = OsGetNextExpireTime(startTime); // 获取下一次到期时间 + Percpu *currCpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针 UINT64 nextResponseTime; BOOL isTimeSlice = FALSE; - currCpu->schedFlag &= ~INT_PEND_TICK; + currCpu->schedFlag &= ~INT_PEND_TICK; // 清除调度标志位中的中断挂起标志 + if (currCpu->responseID == oldResponseID) { - /* This time has expired, and the next time the theory has expired is infinite */ + /* 此次已经到期,下一次理论上到期的时间为无穷大 */ currCpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME; } - /* The current thread's time slice has been consumed, but the current system lock task cannot - * trigger the schedule to release the CPU - */ + /* 当前线程的时间片已经消耗完,但当前系统锁定任务无法触发调度以释放 CPU */ if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) { nextExpireTime = taskEndTime; - isTimeSlice = TRUE; + isTimeSlice = TRUE; // 设置时间片到期标志 } if ((currCpu->responseTime > nextExpireTime) && ((currCpu->responseTime - nextExpireTime) >= OS_TICK_RESPONSE_PRECISION)) { - nextResponseTime = nextExpireTime - startTime; + nextResponseTime = nextExpireTime - startTime; // 计算下一次响应时间 if (nextResponseTime > g_schedTickMaxResponseTime) { - nextResponseTime = g_schedTickMaxResponseTime; + nextResponseTime = g_schedTickMaxResponseTime; // 如果下一次响应时间超过最大响应时间,设置为最大响应时间 } } else { - /* There is no point earlier than the current expiration date */ - currCpu->tickStartTime = 0; + /* 没有比当前到期时间更早的点 */ + currCpu->tickStartTime = 0; // 清零 tick 定时器的启动时间 return; } - OsSchedTickReload(currCpu, nextResponseTime, responseID, isTimeSlice); + OsSchedTickReload(currCpu, nextResponseTime, responseID, isTimeSlice); // 重新加载 tick 定时器 } VOID OsSchedUpdateExpireTime(UINT64 startTime) { UINT64 endTime; - Percpu *cpu = OsPercpuGet(); - LosTaskCB *runTask = OsCurrTaskGet(); + Percpu *cpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针 + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务的控制块指针 if (!OS_SCHEDULER_ACTIVE || OS_INT_ACTIVE) { - cpu->schedFlag |= INT_PEND_TICK; + cpu->schedFlag |= INT_PEND_TICK; // 如果调度器不活跃或者中断活跃,设置调度标志位中的中断挂起标志 return; } @@ -373,435 +419,423 @@ VOID OsSchedUpdateExpireTime(UINT64 startTime) LOS_SpinLock(&g_taskSpin); INT32 timeSlice = (runTask->timeSlice <= OS_TIME_SLICE_MIN) ? runTask->initTimeSlice : runTask->timeSlice; LOS_SpinUnlock(&g_taskSpin); - endTime = startTime + timeSlice; + endTime = startTime + timeSlice; // 计算任务的结束时间 } else { - endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; + endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; // 如果不是轮转调度策略,设置结束时间为最大响应时间减去精度要求 } - OsSchedSetNextExpireTime(startTime, runTask->taskID, endTime, runTask->taskID); + OsSchedSetNextExpireTime(startTime, runTask->taskID, endTime, runTask->taskID); // 设置下一次到期时间 } STATIC INLINE UINT32 OsSchedCalculateTimeSlice(UINT16 proPriority, UINT16 priority) { UINT32 ratTime, readTasks; - SchedQueue *queueList = &g_sched->queueList[proPriority]; - readTasks = queueList->readyTasks[priority]; + SchedQueue *queueList = &g_sched->queueList[proPriority]; // 获取指定优先级的调度队列 + readTasks = queueList->readyTasks[priority]; // 获取指定优先级的就绪任务数量 if (readTasks > OS_SCHED_READY_MAX) { - return OS_SCHED_TIME_SLICES_MIN; + return OS_SCHED_TIME_SLICES_MIN; // 如果就绪任务数量超过最大限制,返回最小时间片 } - ratTime = ((OS_SCHED_READY_MAX - readTasks) * OS_SCHED_TIME_SLICES_DIFF) / OS_SCHED_READY_MAX; - return (ratTime + OS_SCHED_TIME_SLICES_MIN); + ratTime = ((OS_SCHED_READY_MAX - readTasks) * OS_SCHED_TIME_SLICES_DIFF) / OS_SCHED_READY_MAX; // 计算时间片 + return (ratTime + OS_SCHED_TIME_SLICES_MIN); // 返回计算出的时间片 } - STATIC INLINE VOID OsSchedPriQueueEnHead(UINT32 proPriority, LOS_DL_LIST *priqueueItem, UINT32 priority) { - SchedQueue *queueList = &g_sched->queueList[proPriority]; - LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; - UINT32 *bitMap = &queueList->queueBitmap; + SchedQueue *queueList = &g_sched->queueList[proPriority]; // 获取指定优先级的调度队列 + LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; // 获取指定优先级的优先级队列 + UINT32 *bitMap = &queueList->queueBitmap; // 获取位图 /* - * Task control blocks are inited as zero. And when task is deleted, - * and at the same time would be deleted from priority queue or - * other lists, task pend node will restored as zero. + * 任务控制块被初始化为零。当任务被删除时, + * 同时从优先级队列或其他列表中删除,任务挂起节点将被恢复为零。 */ - LOS_ASSERT(priqueueItem->pstNext == NULL); + LOS_ASSERT(priqueueItem->pstNext == NULL); // 断言优先级队列项的下一个节点为空 if (*bitMap == 0) { - g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; + g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; // 如果位图为零,设置全局位图中对应的位 } if (LOS_ListEmpty(&priQueueList[priority])) { - *bitMap |= PRIQUEUE_PRIOR0_BIT >> priority; + *bitMap |= PRIQUEUE_PRIOR0_BIT >> priority; // 如果指定优先级的优先级队列为空,设置位图中对应的位 } - LOS_ListHeadInsert(&priQueueList[priority], priqueueItem); - queueList->readyTasks[priority]++; + LOS_ListHeadInsert(&priQueueList[priority], priqueueItem); // 将优先级队列项插入到指定优先级的队列头部 + queueList->readyTasks[priority]++; // 增加指定优先级的就绪任务数量 } STATIC INLINE VOID OsSchedPriQueueEnTail(UINT32 proPriority, LOS_DL_LIST *priqueueItem, UINT32 priority) { - SchedQueue *queueList = &g_sched->queueList[proPriority]; - LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; - UINT32 *bitMap = &queueList->queueBitmap; + SchedQueue *queueList = &g_sched->queueList[proPriority]; // 获取指定优先级的调度队列 + LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; // 获取指定优先级的优先级队列 + UINT32 *bitMap = &queueList->queueBitmap; // 获取位图 /* - * Task control blocks are inited as zero. And when task is deleted, - * and at the same time would be deleted from priority queue or - * other lists, task pend node will restored as zero. + * 任务控制块被初始化为零。当任务被删除时, + * 同时从优先级队列或其他列表中删除,任务挂起节点将被恢复为零。 */ - LOS_ASSERT(priqueueItem->pstNext == NULL); + LOS_ASSERT(priqueueItem->pstNext == NULL); // 断言优先级队列项的下一个节点为空 if (*bitMap == 0) { - g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; + g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; // 如果位图为零,设置全局位图中对应的位 } if (LOS_ListEmpty(&priQueueList[priority])) { - *bitMap |= PRIQUEUE_PRIOR0_BIT >> priority; + *bitMap |= PRIQUEUE_PRIOR0_BIT >> priority; // 如果指定优先级的优先级队列为空,设置位图中对应的位 } - LOS_ListTailInsert(&priQueueList[priority], priqueueItem); - queueList->readyTasks[priority]++; + LOS_ListTailInsert(&priQueueList[priority], priqueueItem); // 将优先级队列项插入到指定优先级的队列尾部 + queueList->readyTasks[priority]++; // 增加指定优先级的就绪任务数量 } STATIC INLINE VOID OsSchedPriQueueDelete(UINT32 proPriority, LOS_DL_LIST *priqueueItem, UINT32 priority) { - SchedQueue *queueList = &g_sched->queueList[proPriority]; - LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; - UINT32 *bitMap = &queueList->queueBitmap; + SchedQueue *queueList = &g_sched->queueList[proPriority]; // 获取指定优先级的调度队列 + LOS_DL_LIST *priQueueList = &queueList->priQueueList[0]; // 获取指定优先级的优先级队列 + UINT32 *bitMap = &queueList->queueBitmap; // 获取位图 - LOS_ListDelete(priqueueItem); - queueList->readyTasks[priority]--; + LOS_ListDelete(priqueueItem); // 从优先级队列中删除优先级队列项 + queueList->readyTasks[priority]--; // 减少指定优先级的就绪任务数量 if (LOS_ListEmpty(&priQueueList[priority])) { - *bitMap &= ~(PRIQUEUE_PRIOR0_BIT >> priority); + *bitMap &= ~(PRIQUEUE_PRIOR0_BIT >> priority); // 如果指定优先级的优先级队列为空,清除位图中对应的位 } if (*bitMap == 0) { - g_sched->queueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> proPriority); + g_sched->queueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> proPriority); // 如果位图为零,清除全局位图中对应的位 } } - STATIC INLINE VOID OsSchedWakePendTimeTask(UINT64 currTime, LosTaskCB *taskCB, BOOL *needSchedule) { #ifndef LOSCFG_SCHED_DEBUG (VOID)currTime; #endif - LOS_SpinLock(&g_taskSpin); - UINT16 tempStatus = taskCB->taskStatus; + LOS_SpinLock(&g_taskSpin); // 获取全局任务自旋锁 + UINT16 tempStatus = taskCB->taskStatus; // 获取任务的状态 if (tempStatus & (OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY)) { - taskCB->taskStatus &= ~(OS_TASK_STATUS_PENDING | OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY); + taskCB->taskStatus &= ~(OS_TASK_STATUS_PENDING | OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY); // 清除任务的挂起状态和延时状态 if (tempStatus & OS_TASK_STATUS_PENDING) { #ifdef LOSCFG_KERNEL_LITEIPC - taskCB->ipcStatus &= ~IPC_THREAD_STATUS_PEND; + taskCB->ipcStatus &= ~IPC_THREAD_STATUS_PEND; // 清除任务的轻量级 IPC 挂起状态 #endif - taskCB->taskStatus |= OS_TASK_STATUS_TIMEOUT; - LOS_ListDelete(&taskCB->pendList); - taskCB->taskMux = NULL; - OsTaskWakeClearPendMask(taskCB); + taskCB->taskStatus |= OS_TASK_STATUS_TIMEOUT; // 设置任务的超时状态 + LOS_ListDelete(&taskCB->pendList); // 从挂起任务列表中删除任务 + taskCB->taskMux = NULL; // 清除任务的互斥信号量 + OsTaskWakeClearPendMask(taskCB); // 清除任务的挂起掩码 } if (!(tempStatus & OS_TASK_STATUS_SUSPENDED)) { #ifdef LOSCFG_SCHED_DEBUG - taskCB->schedStat.pendTime += currTime - taskCB->startTime; - taskCB->schedStat.pendCount++; + taskCB->schedStat.pendTime += currTime - taskCB->startTime; // 更新任务的挂起时间统计 + taskCB->schedStat.pendCount++; // 增加任务的挂起次数统计 #endif - OsSchedTaskEnQueue(taskCB); - *needSchedule = TRUE; + OsSchedTaskEnQueue(taskCB); // 将任务加入调度队列 + *needSchedule = TRUE; // 设置需要进行调度 } } - LOS_SpinUnlock(&g_taskSpin); + LOS_SpinUnlock(&g_taskSpin); // 释放全局任务自旋锁 } STATIC INLINE BOOL OsSchedScanTimerList(VOID) { - Percpu *cpu = OsPercpuGet(); - BOOL needSchedule = FALSE; - SortLinkAttribute *taskSortLink = &OsPercpuGet()->taskSortLink; - LOS_DL_LIST *listObject = &taskSortLink->sortLink; + Percpu *cpu = OsPercpuGet(); // 获取当前 CPU 的 Per-CPU 变量 + BOOL needSchedule = FALSE; // 标记是否需要进行调度 + SortLinkAttribute *taskSortLink = &OsPercpuGet()->taskSortLink; // 获取当前 CPU 的任务排序链表属性 + LOS_DL_LIST *listObject = &taskSortLink->sortLink; // 获取当前 CPU 的任务排序链表 /* - * When task is pended with timeout, the task block is on the timeout sortlink - * (per cpu) and ipc(mutex,sem and etc.)'s block at the same time, it can be waken - * up by either timeout or corresponding ipc it's waiting. + * 当任务被挂起并设置了超时时,任务块会同时存在于超时排序链表 + * (每个 CPU 都有一个) 和相应的 IPC(互斥信号量、信号量等)的链表中, + * 它可以通过超时或等待的 IPC 被唤醒。 * - * Now synchronize sortlink preocedure is used, therefore the whole task scan needs - * to be protected, preventing another core from doing sortlink deletion at same time. + * 现在使用同步的排序链表过程,因此整个任务扫描需要保护, + * 防止另一个核心同时进行排序链表的删除操作。 */ - LOS_SpinLock(&cpu->taskSortLinkSpin); + LOS_SpinLock(&cpu->taskSortLinkSpin); // 获取当前 CPU 的任务排序链表自旋锁 if (LOS_ListEmpty(listObject)) { LOS_SpinUnlock(&cpu->taskSortLinkSpin); return needSchedule; } - SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); - UINT64 currTime = OsGetCurrSchedTimeCycle(); + SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); // 获取排序链表的第一个任务节点 + UINT64 currTime = OsGetCurrSchedTimeCycle(); // 获取当前调度时间 while (sortList->responseTime <= currTime) { - LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(sortList, LosTaskCB, sortList); - OsDeleteNodeSortLink(taskSortLink, &taskCB->sortList); - LOS_SpinUnlock(&cpu->taskSortLinkSpin); + LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(sortList, LosTaskCB, sortList); // 获取任务控制块 + OsDeleteNodeSortLink(taskSortLink, &taskCB->sortList); // 从排序链表中删除任务节点 + LOS_SpinUnlock(&cpu->taskSortLinkSpin); // 释放当前 CPU 的任务排序链表自旋锁 - OsSchedWakePendTimeTask(currTime, taskCB, &needSchedule); + OsSchedWakePendTimeTask(currTime, taskCB, &needSchedule); // 唤醒被挂起的超时任务 - LOS_SpinLock(&cpu->taskSortLinkSpin); + LOS_SpinLock(&cpu->taskSortLinkSpin); // 获取当前 CPU 的任务排序链表自旋锁 if (LOS_ListEmpty(listObject)) { break; } - sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); + sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); // 获取排序链表的下一个任务节点 } - LOS_SpinUnlock(&cpu->taskSortLinkSpin); + LOS_SpinUnlock(&cpu->taskSortLinkSpin); // 释放当前 CPU 的任务排序链表自旋锁 - return needSchedule; + return needSchedule; // 返回是否需要进行调度 } - STATIC INLINE VOID OsSchedEnTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB) { - LOS_ASSERT(!(taskCB->taskStatus & OS_TASK_STATUS_READY)); + LOS_ASSERT(!(taskCB->taskStatus & OS_TASK_STATUS_READY)); // 断言任务不处于就绪状态 switch (taskCB->policy) { case LOS_SCHED_RR: { - if (taskCB->timeSlice > OS_TIME_SLICE_MIN) { - OsSchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority); + if (taskCB->timeSlice > OS_TIME_SLICE_MIN) { // 如果时间片大于最小时间片 + OsSchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority); // 将任务加入就绪队列的头部 } else { - taskCB->initTimeSlice = OsSchedCalculateTimeSlice(processCB->priority, taskCB->priority); - taskCB->timeSlice = taskCB->initTimeSlice; - OsSchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority); + taskCB->initTimeSlice = OsSchedCalculateTimeSlice(processCB->priority, taskCB->priority); // 计算任务的初始时间片 + taskCB->timeSlice = taskCB->initTimeSlice; // 设置任务的时间片 + OsSchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority); // 将任务加入就绪队列的尾部 #ifdef LOSCFG_SCHED_DEBUG - taskCB->schedStat.timeSliceTime = taskCB->schedStat.timeSliceRealTime; - taskCB->schedStat.timeSliceCount++; + taskCB->schedStat.timeSliceTime = taskCB->schedStat.timeSliceRealTime; // 更新任务的时间片统计 + taskCB->schedStat.timeSliceCount++; // 增加任务的时间片计数 #endif } break; } case LOS_SCHED_FIFO: { - /* The time slice of FIFO is always greater than 0 unless the yield is called */ - if ((taskCB->timeSlice > OS_TIME_SLICE_MIN) && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) { - OsSchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority); + /* FIFO 调度策略的时间片总是大于 0,除非调用了 yield */ + if ((taskCB->timeSlice > OS_TIME_SLICE_MIN) && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) { // 如果时间片大于最小时间片且任务正在运行 + OsSchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority); // 将任务加入就绪队列的头部 } else { - taskCB->initTimeSlice = OS_SCHED_FIFO_TIMEOUT; - taskCB->timeSlice = taskCB->initTimeSlice; - OsSchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority); + taskCB->initTimeSlice = OS_SCHED_FIFO_TIMEOUT; // 设置任务的初始时间片为 FIFO 超时时间 + taskCB->timeSlice = taskCB->initTimeSlice; // 设置任务的时间片 + OsSchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority); // 将任务加入就绪队列的尾部 } break; } case LOS_SCHED_IDLE: #ifdef LOSCFG_SCHED_DEBUG - taskCB->schedStat.timeSliceCount = 1; + taskCB->schedStat.timeSliceCount = 1; // 设置任务的时间片计数为 1 #endif break; default: - LOS_ASSERT(0); + LOS_ASSERT(0); // 断言不会执行到这里 break; } - taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED; - taskCB->taskStatus |= OS_TASK_STATUS_READY; + taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED; // 清除任务的阻塞状态 + taskCB->taskStatus |= OS_TASK_STATUS_READY; // 设置任务的就绪状态 - processCB->processStatus &= ~(OS_PROCESS_STATUS_INIT | OS_PROCESS_STATUS_PENDING); - processCB->processStatus |= OS_PROCESS_STATUS_READY; - processCB->readyTaskNum++; + processCB->processStatus &= ~(OS_PROCESS_STATUS_INIT | OS_PROCESS_STATUS_PENDING); // 清除进程的初始化和挂起状态 + processCB->processStatus |= OS_PROCESS_STATUS_READY; // 设置进程的就绪状态 + processCB->readyTaskNum++; // 增加进程的就绪任务数 } STATIC INLINE VOID OsSchedDeTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB) { - if (taskCB->policy != LOS_SCHED_IDLE) { - OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority); + if (taskCB->policy != LOS_SCHED_IDLE) { // 如果任务的调度策略不是 IDLE + OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority); // 从就绪队列中删除任务 } - taskCB->taskStatus &= ~OS_TASK_STATUS_READY; + taskCB->taskStatus &= ~OS_TASK_STATUS_READY; // 清除任务的就绪状态 - processCB->readyTaskNum--; + processCB->readyTaskNum--; // 减少进程的就绪任务数 if (processCB->readyTaskNum == 0) { - processCB->processStatus &= ~OS_PROCESS_STATUS_READY; + processCB->processStatus &= ~OS_PROCESS_STATUS_READY; // 如果进程的就绪任务数为 0,则清除进程的就绪状态 } } VOID OsSchedTaskDeQueue(LosTaskCB *taskCB) { - LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); + LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); // 获取任务所属进程的控制块 - if (taskCB->taskStatus & OS_TASK_STATUS_READY) { - OsSchedDeTaskQueue(taskCB, processCB); + if (taskCB->taskStatus & OS_TASK_STATUS_READY) { // 如果任务处于就绪状态 + OsSchedDeTaskQueue(taskCB, processCB); // 从就绪队列中删除任务 } - if (processCB->processStatus & OS_PROCESS_STATUS_READY) { + if (processCB->processStatus & OS_PROCESS_STATUS_READY) { // 如果进程处于就绪状态 return; } - /* If the current process has only the current thread running, - * the process becomes blocked after the thread leaves the scheduling queue + /* 如果当前进程只有当前线程在运行, + * 那么线程离开调度队列后进程将变为阻塞状态 */ if (OS_PROCESS_GET_RUNTASK_COUNT(processCB->processStatus) == 1) { - processCB->processStatus |= OS_PROCESS_STATUS_PENDING; + processCB->processStatus |= OS_PROCESS_STATUS_PENDING; // 设置进程的挂起状态 } } VOID OsSchedTaskEnQueue(LosTaskCB *taskCB) { - LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); + LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); // 获取任务所属进程的控制块 #ifdef LOSCFG_SCHED_DEBUG - if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) { - taskCB->startTime = OsGetCurrSchedTimeCycle(); + if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) { // 如果任务不是正在运行状态 + taskCB->startTime = OsGetCurrSchedTimeCycle(); // 记录任务的启动时间 } #endif - OsSchedEnTaskQueue(taskCB, processCB); + OsSchedEnTaskQueue(taskCB, processCB); // 将任务加入就绪队列 } VOID OsSchedTaskExit(LosTaskCB *taskCB) { - LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); + LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); // 获取任务所属进程的控制块 - if (taskCB->taskStatus & OS_TASK_STATUS_READY) { - OsSchedTaskDeQueue(taskCB); - processCB->processStatus &= ~OS_PROCESS_STATUS_PENDING; - } else if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) { - LOS_ListDelete(&taskCB->pendList); - taskCB->taskStatus &= ~OS_TASK_STATUS_PENDING; + if (taskCB->taskStatus & OS_TASK_STATUS_READY) { // 如果任务处于就绪状态 + OsSchedTaskDeQueue(taskCB); // 从就绪队列中删除任务 + processCB->processStatus &= ~OS_PROCESS_STATUS_PENDING; // 清除进程的挂起状态 + } else if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) { // 如果任务处于挂起状态 + LOS_ListDelete(&taskCB->pendList); // 从挂起队列中删除任务 + taskCB->taskStatus &= ~OS_TASK_STATUS_PENDING; // 清除任务的挂起状态 } - if (taskCB->taskStatus & (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)) { - OsDeleteSortLink(&taskCB->sortList, OS_SORT_LINK_TASK); - taskCB->taskStatus &= ~(OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME); + if (taskCB->taskStatus & (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)) { // 如果任务处于延时或等待定时状态 + OsDeleteSortLink(&taskCB->sortList, OS_SORT_LINK_TASK); // 从排序链表中删除任务 + taskCB->taskStatus &= ~(OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME); // 清除任务的延时和等待定时状态 } } VOID OsSchedYield(VOID) { - LosTaskCB *runTask = OsCurrTaskGet(); + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 - runTask->timeSlice = 0; + runTask->timeSlice = 0; // 将任务的时间片设置为 0 - runTask->startTime = OsGetCurrSchedTimeCycle(); - OsSchedTaskEnQueue(runTask); - OsSchedResched(); + runTask->startTime = OsGetCurrSchedTimeCycle(); // 记录任务的启动时间 + OsSchedTaskEnQueue(runTask); // 将任务加入就绪队列 + OsSchedResched(); // 进行调度 } VOID OsSchedDelay(LosTaskCB *runTask, UINT32 tick) { - OsSchedTaskDeQueue(runTask); - runTask->taskStatus |= OS_TASK_STATUS_DELAY; - runTask->waitTimes = tick; + OsSchedTaskDeQueue(runTask); // 从就绪队列中删除任务 + runTask->taskStatus |= OS_TASK_STATUS_DELAY; // 设置任务的延时状态 + runTask->waitTimes = tick; // 设置任务的等待时间 - OsSchedResched(); + OsSchedResched(); // 进行调度 } UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched) { - LosTaskCB *runTask = OsCurrTaskGet(); - OsSchedTaskDeQueue(runTask); + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 + OsSchedTaskDeQueue(runTask); // 从就绪队列中删除任务 - runTask->taskStatus |= OS_TASK_STATUS_PENDING; - LOS_ListTailInsert(list, &runTask->pendList); + runTask->taskStatus |= OS_TASK_STATUS_PENDING; // 设置任务的挂起状态 + LOS_ListTailInsert(list, &runTask->pendList); // 将任务插入挂起队列的尾部 - if (ticks != LOS_WAIT_FOREVER) { - runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME; - runTask->waitTimes = ticks; + if (ticks != LOS_WAIT_FOREVER) { // 如果等待时间不是永远 + runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME; // 设置任务的等待定时状态 + runTask->waitTimes = ticks; // 设置任务的等待时间 } - if (needSched == TRUE) { - OsSchedResched(); - if (runTask->taskStatus & OS_TASK_STATUS_TIMEOUT) { - runTask->taskStatus &= ~OS_TASK_STATUS_TIMEOUT; - return LOS_ERRNO_TSK_TIMEOUT; + if (needSched == TRUE) { // 如果需要进行调度 + OsSchedResched(); // 进行调度 + if (runTask->taskStatus & OS_TASK_STATUS_TIMEOUT) { // 如果任务超时 + runTask->taskStatus &= ~OS_TASK_STATUS_TIMEOUT; // 清除任务的超时状态 + return LOS_ERRNO_TSK_TIMEOUT; // 返回超时错误 } } - return LOS_OK; + return LOS_OK; // 返回成功 } VOID OsSchedTaskWake(LosTaskCB *resumedTask) { - LOS_ListDelete(&resumedTask->pendList); - resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING; + LOS_ListDelete(&resumedTask->pendList); // 从挂起队列中删除任务 + resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING; // 清除任务的挂起状态 - if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) { - OsDeleteSortLink(&resumedTask->sortList, OS_SORT_LINK_TASK); - resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME; + if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) { // 如果任务处于等待定时状态 + OsDeleteSortLink(&resumedTask->sortList, OS_SORT_LINK_TASK); // 从排序链表中删除任务 + resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME; // 清除任务的等待定时状态 } - if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) { + if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) { // 如果任务没有被挂起 #ifdef LOSCFG_SCHED_DEBUG - resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime; - resumedTask->schedStat.pendCount++; -#endif - OsSchedTaskEnQueue(resumedTask); - } -} - + resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask-> BOOL OsSchedModifyTaskSchedParam(LosTaskCB *taskCB, UINT16 policy, UINT16 priority) { - if (taskCB->policy != policy) { - taskCB->policy = policy; - taskCB->timeSlice = 0; + if (taskCB->policy != policy) { // 如果任务的调度策略与传入的策略不同 + taskCB->policy = policy; // 更新任务的调度策略 + taskCB->timeSlice = 0; // 将任务的时间片设置为 0 } - if (taskCB->taskStatus & OS_TASK_STATUS_READY) { - OsSchedTaskDeQueue(taskCB); - taskCB->priority = priority; - OsSchedTaskEnQueue(taskCB); - return TRUE; + if (taskCB->taskStatus & OS_TASK_STATUS_READY) { // 如果任务处于就绪状态 + OsSchedTaskDeQueue(taskCB); // 从就绪队列中删除任务 + taskCB->priority = priority; // 更新任务的优先级 + OsSchedTaskEnQueue(taskCB); // 将任务加入就绪队列 + return TRUE; // 返回需要进行调度 } - taskCB->priority = priority; - OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority); - if (taskCB->taskStatus & OS_TASK_STATUS_INIT) { - OsSchedTaskEnQueue(taskCB); - return TRUE; + taskCB->priority = priority; // 更新任务的优先级 + OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority); // 调用任务优先级修改的钩子函数 + if (taskCB->taskStatus & OS_TASK_STATUS_INIT) { // 如果任务处于初始化状态 + OsSchedTaskEnQueue(taskCB); // 将任务加入就绪队列 + return TRUE; // 返回需要进行调度 } - if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) { - return TRUE; + if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) { // 如果任务处于运行状态 + return TRUE; // 返回需要进行调度 } - return FALSE; + return FALSE; // 返回不需要进行调度 } BOOL OsSchedModifyProcessSchedParam(LosProcessCB *processCB, UINT16 policy, UINT16 priority) { LosTaskCB *taskCB = NULL; BOOL needSched = FALSE; - (VOID)policy; + (VOID)policy; // 忽略传入的调度策略 - if (processCB->processStatus & OS_PROCESS_STATUS_READY) { + if (processCB->processStatus & OS_PROCESS_STATUS_READY) { // 如果进程处于就绪状态 LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) { - if (taskCB->taskStatus & OS_TASK_STATUS_READY) { - OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority); - OsSchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority); - needSched = TRUE; + if (taskCB->taskStatus & OS_TASK_STATUS_READY) { // 如果任务处于就绪状态 + OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority); // 从优先级队列中删除任务 + OsSchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority); // 将任务按照新的优先级插入到优先级队列中 + needSched = TRUE; // 需要进行调度 } } } - processCB->priority = priority; - if (processCB->processStatus & OS_PROCESS_STATUS_RUNNING) { - needSched = TRUE; + processCB->priority = priority; // 更新进程的优先级 + if (processCB->processStatus & OS_PROCESS_STATUS_RUNNING) { // 如果进程处于运行状态 + needSched = TRUE; // 需要进行调度 } - return needSched; + return needSched; // 返回是否需要进行调度 } VOID OsSchedTick(VOID) { - Sched *sched = g_sched; - Percpu *currCpu = OsPercpuGet(); - BOOL needSched = FALSE; - LosTaskCB *runTask = OsCurrTaskGet(); - - currCpu->tickStartTime = runTask->irqStartTime; - if (currCpu->responseID == OS_INVALID_VALUE) { - if (sched->swtmrScan != NULL) { - (VOID)sched->swtmrScan(); + Sched *sched = g_sched; // 获取全局调度器结构体指针 + Percpu *currCpu = OsPercpuGet(); // 获取当前 CPU 的私有数据结构指针 + BOOL needSched = FALSE; // 是否需要进行调度 + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 + + currCpu->tickStartTime = runTask->irqStartTime; // 记录当前时钟中断的开始时间 + if (currCpu->responseID == OS_INVALID_VALUE) { // 如果当前 CPU 的响应 ID 无效 + if (sched->swtmrScan != NULL) { // 如果软件定时器扫描函数不为空 + (VOID)sched->swtmrScan(); // 执行软件定时器扫描函数 } - needSched = sched->taskScan(); + needSched = sched->taskScan(); // 执行任务扫描函数,判断是否需要进行调度 - if (needSched) { - LOS_MpSchedule(OS_MP_CPU_ALL); - currCpu->schedFlag |= INT_PEND_RESCH; + if (needSched) { // 如果需要进行调度 + LOS_MpSchedule(OS_MP_CPU_ALL); // 进行多核调度 + currCpu->schedFlag |= INT_PEND_RESCH; // 设置调度标志位 } } - currCpu->schedFlag |= INT_PEND_TICK; - currCpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME; + currCpu->schedFlag |= INT_PEND_TICK; // 设置时钟中断调度标志位 + currCpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME; // 设置响应时间的上限 } VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask) { - idleTask->policy = LOS_SCHED_IDLE; - idleTask->initTimeSlice = OS_SCHED_FIFO_TIMEOUT; - idleTask->timeSlice = idleTask->initTimeSlice; - OsSchedTaskEnQueue(idleTask); + idleTask->policy = LOS_SCHED_IDLE; // 设置空闲任务的调度策略为 LOS_SCHED_IDLE + idleTask->initTimeSlice = OS_SCHED_FIFO_TIMEOUT; // 设置空闲任务的初始时间片 + idleTask->timeSlice = idleTask->initTimeSlice; // 设置空闲任务的时间片 + OsSchedTaskEnQueue(idleTask); // 将空闲任务加入就绪队列 } - UINT32 OsSchedSwtmrScanRegister(SchedScan func) { - if (func == NULL) { - return LOS_NOK; + if (func == NULL) { // 如果传入的函数指针为空 + return LOS_NOK; // 返回失败 } - g_sched->swtmrScan = func; - return LOS_OK; + g_sched->swtmrScan = func; // 注册软件定时器扫描函数 + return LOS_OK; // 返回成功 } UINT32 OsSchedInit(VOID) @@ -809,143 +843,140 @@ UINT32 OsSchedInit(VOID) UINT16 index, pri; UINT32 ret; - g_sched = (Sched *)LOS_MemAlloc(m_aucSysMem0, sizeof(Sched)); - if (g_sched == NULL) { - return LOS_ERRNO_TSK_NO_MEMORY; + g_sched = (Sched *)LOS_MemAlloc(m_aucSysMem0, sizeof(Sched)); // 分配内存给全局调度器结构体指针 + if (g_sched == NULL) { // 如果内存分配失败 + return LOS_ERRNO_TSK_NO_MEMORY; // 返回内存不足错误 } - (VOID)memset_s(g_sched, sizeof(Sched), 0, sizeof(Sched)); + (VOID)memset_s(g_sched, sizeof(Sched), 0, sizeof(Sched)); // 将全局调度器结构体清零 - for (index = 0; index < OS_PRIORITY_QUEUE_NUM; index++) { + for (index = 0; index < OS_PRIORITY_QUEUE_NUM; index++) { // 遍历优先级队列 SchedQueue *queueList = &g_sched->queueList[index]; LOS_DL_LIST *priList = &queueList->priQueueList[0]; - for (pri = 0; pri < OS_PRIORITY_QUEUE_NUM; pri++) { - LOS_ListInit(&priList[pri]); + for (pri = 0; pri < OS_PRIORITY_QUEUE_NUM; pri++) { // 遍历每个优先级队列的优先级 + LOS_ListInit(&priList[pri]); // 初始化优先级队列 } } - for (index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) { - Percpu *cpu = OsPercpuGetByID(index); - ret = OsSortLinkInit(&cpu->taskSortLink); - if (ret != LOS_OK) { - return LOS_ERRNO_TSK_NO_MEMORY; + for (index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) { // 遍历每个 CPU 的私有数据结构 + Percpu *cpu = OsPercpuGetByID(index); // 获取当前 CPU 的私有数据结构指针 + ret = OsSortLinkInit(&cpu->taskSortLink); // 初始化任务排序链表 + if (ret != LOS_OK) { // 如果初始化失败 + return LOS_ERRNO_TSK_NO_MEMORY; // 返回内存不足错误 } - cpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME; - LOS_SpinInit(&cpu->taskSortLinkSpin); - LOS_SpinInit(&cpu->swtmrSortLinkSpin); + cpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME; // 设置响应时间的上限 + LOS_SpinInit(&cpu->taskSortLinkSpin); // 初始化任务排序链表的自旋锁 + LOS_SpinInit(&cpu->swtmrSortLinkSpin); // 初始化软件定时器排序链表的自旋锁 } - g_sched->taskScan = OsSchedScanTimerList; + g_sched->taskScan = OsSchedScanTimerList; // 设置任务扫描函数为默认的定时器扫描函数 #ifdef LOSCFG_SCHED_TICK_DEBUG - ret = OsSchedDebugInit(); - if (ret != LOS_OK) { - return ret; + ret = OsSchedDebugInit(); // 初始化调度器的调试功能 + if (ret != LOS_OK) { // 如果初始化失败 + return ret; // 返回错误码 } #endif - return LOS_OK; + return LOS_OK; // 返回成功 } - STATIC LosTaskCB *OsGetTopTask(VOID) { UINT32 priority, processPriority; UINT32 bitmap; LosTaskCB *newTask = NULL; - UINT32 processBitmap = g_sched->queueBitmap; + UINT32 processBitmap = g_sched->queueBitmap; // 获取全局调度器的进程位图 #ifdef LOSCFG_KERNEL_SMP - UINT32 cpuid = ArchCurrCpuid(); + UINT32 cpuid = ArchCurrCpuid(); // 获取当前 CPU 的 ID #endif - while (processBitmap) { - processPriority = CLZ(processBitmap); - SchedQueue *queueList = &g_sched->queueList[processPriority]; - bitmap = queueList->queueBitmap; - while (bitmap) { - priority = CLZ(bitmap); - LOS_DL_LIST_FOR_EACH_ENTRY(newTask, &queueList->priQueueList[priority], LosTaskCB, pendList) { + while (processBitmap) { // 遍历进程位图 + processPriority = CLZ(processBitmap); // 获取最高优先级的进程 + SchedQueue *queueList = &g_sched->queueList[processPriority]; // 获取对应优先级的队列 + bitmap = queueList->queueBitmap; // 获取优先级队列的位图 + while (bitmap) { // 遍历优先级队列的位图 + priority = CLZ(bitmap); // 获取最高优先级的任务 + LOS_DL_LIST_FOR_EACH_ENTRY(newTask, &queueList->priQueueList[priority], LosTaskCB, pendList) { #ifdef LOSCFG_KERNEL_SMP - if (newTask->cpuAffiMask & (1U << cpuid)) { + if (newTask->cpuAffiMask & (1U << cpuid)) { // 如果任务可以在当前 CPU 上运行 #endif - goto FIND_TASK; + goto FIND_TASK; // 跳转到找到任务的位置 #ifdef LOSCFG_KERNEL_SMP - } -#endif } - bitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - priority - 1)); +#endif + } + bitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - priority - 1)); // 清除已经遍历过的位 } - processBitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - processPriority - 1)); + processBitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - processPriority - 1)); // 清除已经遍历过的位 } - newTask = OS_TCB_FROM_TID(OsPercpuGet()->idleTaskID); + newTask = OS_TCB_FROM_TID(OsPercpuGet()->idleTaskID); // 如果没有找到任务,则返回空闲任务 FIND_TASK: - OsSchedDeTaskQueue(newTask, OS_PCB_FROM_PID(newTask->processID)); - return newTask; + OsSchedDeTaskQueue(newTask, OS_PCB_FROM_PID(newTask->processID)); // 从任务队列中删除任务 + return newTask; // 返回找到的任务 } - VOID OsSchedStart(VOID) { - UINT32 cpuid = ArchCurrCpuid(); + UINT32 cpuid = ArchCurrCpuid(); // 获取当前 CPU 的 ID UINT32 intSave; - SCHEDULER_LOCK(intSave); + SCHEDULER_LOCK(intSave); // 锁住调度器 - if (cpuid == 0) { - OsTickStart(); + if (cpuid == 0) { // 如果是第一个 CPU + OsTickStart(); // 启动系统时钟中断 } - LosTaskCB *newTask = OsGetTopTask(); - LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID); + LosTaskCB *newTask = OsGetTopTask(); // 获取要运行的任务 + LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID); // 获取任务所属的进程 - newTask->taskStatus |= OS_TASK_STATUS_RUNNING; - newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING; - newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus); + newTask->taskStatus |= OS_TASK_STATUS_RUNNING; // 设置任务状态为运行中 + newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING; // 设置进程状态为运行中 + newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus); // 增加进程的运行任务计数 - OsSchedSetStartTime(HalClockGetCycles()); - newTask->startTime = OsGetCurrSchedTimeCycle(); + OsSchedSetStartTime(HalClockGetCycles()); // 设置调度器的起始时间 + newTask->startTime = OsGetCurrSchedTimeCycle(); // 设置任务的起始时间 #ifdef LOSCFG_KERNEL_SMP /* * attention: current cpu needs to be set, in case first task deletion * may fail because this flag mismatch with the real current cpu. */ - newTask->currCpu = cpuid; + newTask->currCpu = cpuid; // 设置任务所在的 CPU #endif - OsCurrTaskSet((VOID *)newTask); + OsCurrTaskSet((VOID *)newTask); // 设置当前任务 /* System start schedule */ - OS_SCHEDULER_SET(cpuid); + OS_SCHEDULER_SET(cpuid); // 设置调度器标志,表示系统已经开始调度 - OsPercpuGet()->responseID = OS_INVALID; - OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, newTask->startTime + newTask->timeSlice, OS_INVALID); + OsPercpuGet()->responseID = OS_INVALID; // 初始化响应 ID + OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, newTask->startTime + newTask->timeSlice, OS_INVALID); // 设置下一个任务的到期时间 - PRINTK("cpu %d entering scheduler\n", cpuid); - OsTaskContextLoad(newTask); + PRINTK("cpu %d entering scheduler\n", cpuid); // 打印进入调度器的消息 + OsTaskContextLoad(newTask); // 加载任务上下文并开始执行任务 } #ifdef LOSCFG_KERNEL_SMP VOID OsSchedToUserReleaseLock(VOID) { /* The scheduling lock needs to be released before returning to user mode */ - LOCKDEP_CHECK_OUT(&g_taskSpin); - ArchSpinUnlock(&g_taskSpin.rawLock); + LOCKDEP_CHECK_OUT(&g_taskSpin); // 检查任务自旋锁是否正确释放 + ArchSpinUnlock(&g_taskSpin.rawLock); // 解锁任务自旋锁 - OsPercpuGet()->taskLockCnt--; + OsPercpuGet()->taskLockCnt--; // 减少任务锁计数 } #endif - #ifdef LOSCFG_BASE_CORE_TSK_MONITOR STATIC VOID OsTaskStackCheck(LosTaskCB *runTask, LosTaskCB *newTask) { - if (!OS_STACK_MAGIC_CHECK(runTask->topOfStack)) { - LOS_Panic("CURRENT task ID: %s:%d stack overflow!\n", runTask->taskName, runTask->taskID); + if (!OS_STACK_MAGIC_CHECK(runTask->topOfStack)) { // 检查当前运行任务的栈是否溢出 + LOS_Panic("CURRENT task ID: %s:%d stack overflow!\n", runTask->taskName, runTask->taskID); // 如果溢出,触发异常并打印错误信息 } if (((UINTPTR)(newTask->stackPointer) <= newTask->topOfStack) || - ((UINTPTR)(newTask->stackPointer) > (newTask->topOfStack + newTask->stackSize))) { + ((UINTPTR)(newTask->stackPointer) > (newTask->topOfStack + newTask->stackSize))) { // 检查新任务的栈指针是否合法 LOS_Panic("HIGHEST task ID: %s:%u SP error! StackPointer: %p TopOfStack: %p\n", - newTask->taskName, newTask->taskID, newTask->stackPointer, newTask->topOfStack); + newTask->taskName, newTask->taskID, newTask->stackPointer, newTask->topOfStack); // 如果不合法,触发异常并打印错误信息 } } #endif @@ -953,178 +984,190 @@ STATIC VOID OsTaskStackCheck(LosTaskCB *runTask, LosTaskCB *newTask) STATIC INLINE VOID OsSchedSwitchCheck(LosTaskCB *runTask, LosTaskCB *newTask) { #ifdef LOSCFG_BASE_CORE_TSK_MONITOR - OsTaskStackCheck(runTask, newTask); + OsTaskStackCheck(runTask, newTask); // 检查任务栈的合法性 #endif /* LOSCFG_BASE_CORE_TSK_MONITOR */ - OsHookCall(LOS_HOOK_TYPE_TASK_SWITCHEDIN, newTask, runTask); + OsHookCall(LOS_HOOK_TYPE_TASK_SWITCHEDIN, newTask, runTask); // 调用任务切换回调函数 } STATIC INLINE VOID OsSchedSwitchProcess(LosProcessCB *runProcess, LosProcessCB *newProcess) { - runProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_DEC(runProcess->processStatus); - newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus); + runProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_DEC(runProcess->processStatus); // 减少当前进程的运行任务计数 + newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus); // 增加新进程的运行任务计数 - LOS_ASSERT(!(OS_PROCESS_GET_RUNTASK_COUNT(newProcess->processStatus) > LOSCFG_KERNEL_CORE_NUM)); - if (OS_PROCESS_GET_RUNTASK_COUNT(runProcess->processStatus) == 0) { - runProcess->processStatus &= ~OS_PROCESS_STATUS_RUNNING; + LOS_ASSERT(!(OS_PROCESS_GET_RUNTASK_COUNT(newProcess->processStatus) > LOSCFG_KERNEL_CORE_NUM)); // 断言新进程的运行任务计数不超过 CPU 核心数 + if (OS_PROCESS_GET_RUNTASK_COUNT(runProcess->processStatus) == 0) { // 如果当前进程的运行任务计数为 0 + runProcess->processStatus &= ~OS_PROCESS_STATUS_RUNNING; // 清除当前进程的运行状态标志 } - LOS_ASSERT(!(newProcess->processStatus & OS_PROCESS_STATUS_PENDING)); - newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING; + LOS_ASSERT(!(newProcess->processStatus & OS_PROCESS_STATUS_PENDING)); // 断言新进程的状态不是挂起状态 + newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING; // 设置新进程的运行状态标志 #ifdef LOSCFG_KERNEL_VM - if (OsProcessIsUserMode(newProcess)) { - LOS_ArchMmuContextSwitch(&newProcess->vmSpace->archMmu); + if (OsProcessIsUserMode(newProcess)) { // 如果新进程是用户态进程 + LOS_ArchMmuContextSwitch(&newProcess->vmSpace->archMmu); // 切换内存管理单元上下文 } #endif - OsCurrProcessSet(newProcess); + OsCurrProcessSet(newProcess); // 设置当前进程为新进程 } - STATIC VOID OsSchedTaskSwicth(LosTaskCB *runTask, LosTaskCB *newTask) { UINT64 endTime; - OsSchedSwitchCheck(runTask, newTask); + OsSchedSwitchCheck(runTask, newTask); // 检查任务切换的相关条件 - runTask->taskStatus &= ~OS_TASK_STATUS_RUNNING; - newTask->taskStatus |= OS_TASK_STATUS_RUNNING; + runTask->taskStatus &= ~OS_TASK_STATUS_RUNNING; // 清除当前任务的运行状态标志 + newTask->taskStatus |= OS_TASK_STATUS_RUNNING; // 设置新任务的运行状态标志 #ifdef LOSCFG_KERNEL_SMP /* mask new running task's owner processor */ - runTask->currCpu = OS_TASK_INVALID_CPUID; - newTask->currCpu = ArchCurrCpuid(); + runTask->currCpu = OS_TASK_INVALID_CPUID; // 设置当前任务的 CPU ID 为无效值 + newTask->currCpu = ArchCurrCpuid(); // 设置新任务的 CPU ID 为当前 CPU 的 ID #endif - OsCurrTaskSet((VOID *)newTask); - LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID); - LosProcessCB *runProcess = OS_PCB_FROM_PID(runTask->processID); - if (runProcess != newProcess) { - OsSchedSwitchProcess(runProcess, newProcess); + OsCurrTaskSet((VOID *)newTask); // 设置当前任务为新任务 + LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID); // 获取新任务所属的进程 + LosProcessCB *runProcess = OS_PCB_FROM_PID(runTask->processID); // 获取当前任务所属的进程 + if (runProcess != newProcess) { // 如果当前任务和新任务所属的进程不同 + OsSchedSwitchProcess(runProcess, newProcess); // 进行进程切换 } - if (OsProcessIsUserMode(newProcess)) { - OsCurrUserTaskSet(newTask->userArea); + if (OsProcessIsUserMode(newProcess)) { // 如果新进程是用户态进程 + OsCurrUserTaskSet(newTask->userArea); // 设置当前用户态任务为新任务的用户态区域 } #ifdef LOSCFG_KERNEL_CPUP - OsCpupCycleEndStart(runTask->taskID, newTask->taskID); + OsCpupCycleEndStart(runTask->taskID, newTask->taskID); // 记录当前任务和新任务的 CPU 周期计数 #endif #ifdef LOSCFG_SCHED_DEBUG - UINT64 waitStartTime = newTask->startTime; + UINT64 waitStartTime = newTask->startTime; // 保存等待调度的起始时间 #endif if (runTask->taskStatus & OS_TASK_STATUS_READY) { /* When a thread enters the ready queue, its slice of time is updated */ - newTask->startTime = runTask->startTime; + newTask->startTime = runTask->startTime; // 如果当前任务是就绪状态,则将新任务的起始时间设置为当前任务的起始时间 } else { /* The currently running task is blocked */ - newTask->startTime = OsGetCurrSchedTimeCycle(); + newTask->startTime = OsGetCurrSchedTimeCycle(); // 如果当前任务是阻塞状态,则将新任务的起始时间设置为当前调度时间 /* The task is in a blocking state and needs to update its time slice before pend */ - OsTimeSliceUpdate(runTask, newTask->startTime); + OsTimeSliceUpdate(runTask, newTask->startTime); // 更新当前任务的时间片 if (runTask->taskStatus & (OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY)) { - OsAdd2SortLink(&runTask->sortList, runTask->startTime, runTask->waitTimes, OS_SORT_LINK_TASK); + OsAdd2SortLink(&runTask->sortList, runTask->startTime, runTask->waitTimes, OS_SORT_LINK_TASK); // 将当前任务添加到排序链表中 } } if (newTask->policy == LOS_SCHED_RR) { - endTime = newTask->startTime + newTask->timeSlice; + endTime = newTask->startTime + newTask->timeSlice; // 如果新任务是轮转调度策略,则计算新任务的结束时间 } else { - endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; + endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; // 如果新任务不是轮转调度策略,则设置新任务的结束时间为最大响应时间 } - OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, endTime, runTask->taskID); + OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, endTime, runTask->taskID); // 设置下一个任务的到期时间 #ifdef LOSCFG_SCHED_DEBUG - newTask->schedStat.waitSchedTime += newTask->startTime - waitStartTime; - newTask->schedStat.waitSchedCount++; - runTask->schedStat.runTime = runTask->schedStat.allRuntime; - runTask->schedStat.switchCount++; + newTask->schedStat.waitSchedTime += newTask->startTime - waitStartTime; // 更新新任务的等待调度时间 + newTask->schedStat.waitSchedCount++; // 增加新任务的等待调度次数 + runTask->schedStat.runTime = runTask->schedStat.allRuntime; // 更新当前任务的运行时间 + runTask->schedStat.switchCount++; // 增加当前任务的切换次数 #endif /* do the task context switch */ - OsTaskSchedule(newTask, runTask); + OsTaskSchedule(newTask, runTask); // 进行任务上下文切换 } +//在切换任务之前,它首先调用OsSchedSwitchCheck函数来检查任务切换的相关条件。然后,它更新当前任务和新任务的运行状态标志,并进行一些其他操作,如设置当前任务、进行进程切换、设置用户态任务等。接下来,它根据任务的状态更新新任务的起始时间,并设置下一个任务的到期时间。最后,它调用OsTaskSchedule函数进行任务上下文切换。 VOID OsSchedIrqEndCheckNeedSched(VOID) { - Percpu *percpu = OsPercpuGet(); - LosTaskCB *runTask = OsCurrTaskGet(); + Percpu *percpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针 + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 - OsTimeSliceUpdate(runTask, OsGetCurrSchedTimeCycle()); - if (runTask->timeSlice <= OS_TIME_SLICE_MIN) { - percpu->schedFlag |= INT_PEND_RESCH; + OsTimeSliceUpdate(runTask, OsGetCurrSchedTimeCycle()); // 更新当前任务的时间片 + if (runTask->timeSlice <= OS_TIME_SLICE_MIN) { // 如果当前任务的时间片小于等于最小时间片 + percpu->schedFlag |= INT_PEND_RESCH; // 设置调度标志,表示需要进行任务切换 } - if (OsPreemptable() && (percpu->schedFlag & INT_PEND_RESCH)) { - percpu->schedFlag &= ~INT_PEND_RESCH; + if (OsPreemptable() && (percpu->schedFlag & INT_PEND_RESCH)) { // 如果可以抢占且需要进行任务切换 + percpu->schedFlag &= ~INT_PEND_RESCH; // 清除调度标志 - LOS_SpinLock(&g_taskSpin); + LOS_SpinLock(&g_taskSpin); // 获取任务自旋锁 - OsSchedTaskEnQueue(runTask); + OsSchedTaskEnQueue(runTask); // 将当前任务加入就绪队列 - LosTaskCB *newTask = OsGetTopTask(); - if (runTask != newTask) { - OsSchedTaskSwicth(runTask, newTask); - LOS_SpinUnlock(&g_taskSpin); + LosTaskCB *newTask = OsGetTopTask(); // 获取优先级最高的任务 + if (runTask != newTask) { // 如果当前任务不是优先级最高的任务 + OsSchedTaskSwicth(runTask, newTask); // 进行任务切换 + LOS_SpinUnlock(&g_taskSpin); // 释放任务自旋锁 return; } - LOS_SpinUnlock(&g_taskSpin); + LOS_SpinUnlock(&g_taskSpin); // 释放任务自旋锁 } - if (percpu->schedFlag & INT_PEND_TICK) { - OsSchedUpdateExpireTime(runTask->startTime); + if (percpu->schedFlag & INT_PEND_TICK) { // 如果有时钟中断挂起 + OsSchedUpdateExpireTime(runTask->startTime); // 更新任务的到期时间 } } VOID OsSchedResched(VOID) { - LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); + LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); // 断言任务自旋锁已持有 #ifdef LOSCFG_KERNEL_SMP - LOS_ASSERT(OsPercpuGet()->taskLockCnt == 1); + LOS_ASSERT(OsPercpuGet()->taskLockCnt == 1); // 断言任务锁计数为1 #else - LOS_ASSERT(OsPercpuGet()->taskLockCnt == 0); + LOS_ASSERT(OsPercpuGet()->taskLockCnt == 0); // 断言任务锁计数为0 #endif - OsPercpuGet()->schedFlag &= ~INT_PEND_RESCH; - LosTaskCB *runTask = OsCurrTaskGet(); - LosTaskCB *newTask = OsGetTopTask(); - if (runTask == newTask) { + OsPercpuGet()->schedFlag &= ~INT_PEND_RESCH; // 清除调度标志 + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 + LosTaskCB *newTask = OsGetTopTask(); // 获取优先级最高的任务 + if (runTask == newTask) { // 如果当前任务就是优先级最高的任务 return; } - OsSchedTaskSwicth(runTask, newTask); + OsSchedTaskSwicth(runTask, newTask); // 进行任务切换 } +/*这段代码实现了在中断结束时检查是否需要进行任务切换的函数OsSchedIrqEndCheckNeedSched, +以及在调度器需要重新调度时执行任务切换的函数OsSchedResched。 + +OsSchedIrqEndCheckNeedSched函数首先更新当前任务的时间片,并检查当前任务的时间片是否小于 +等于最小时间片。如果是,则设置调度标志,表示需要进行任务切换。然后,它检查是否可以抢占且 +调度标志已被设置。如果满足条件,则获取任务自旋锁,并将当前任务加入就绪队列。接下来,它获 +取优先级最高的任务,如果当前任务不是优先级最高的任务,则进行任务切换,并释放任务自旋锁。 +最后,如果有时钟中断挂起,它更新任务的到期时间。 + +OsSchedResched函数首先断言任务自旋锁已持有,并根据配置选项判断任务锁计数是否为1(SMP) +或者为0(非SMP)。然后,它清除调度标志,并获取当前运行的任务和优先级最高的任务。如果当前 +任务就是优先级最高的任务,则直接返回。否则,它进行任务切换。*/ VOID LOS_Schedule(VOID) { UINT32 intSave; - LosTaskCB *runTask = OsCurrTaskGet(); + LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务 - if (OS_INT_ACTIVE) { - OsPercpuGet()->schedFlag |= INT_PEND_RESCH; + if (OS_INT_ACTIVE) { // 如果处于中断上下文 + OsPercpuGet()->schedFlag |= INT_PEND_RESCH; // 设置调度标志,表示需要进行任务切换 return; } - if (!OsPreemptable()) { + if (!OsPreemptable()) { // 如果不允许抢占 return; } /* * trigger schedule in task will also do the slice check - * if neccessary, it will give up the timeslice more in time. - * otherwhise, there's no other side effects. + * if necessary, it will give up the timeslice more in time. + * otherwise, there's no other side effects. */ - SCHEDULER_LOCK(intSave); + SCHEDULER_LOCK(intSave); // 获取调度器锁,禁止调度器抢占 - OsTimeSliceUpdate(runTask, OsGetCurrSchedTimeCycle()); + OsTimeSliceUpdate(runTask, OsGetCurrSchedTimeCycle()); // 更新当前任务的时间片 /* add run task back to ready queue */ - OsSchedTaskEnQueue(runTask); + OsSchedTaskEnQueue(runTask); // 将当前任务加入就绪队列 /* reschedule to new thread */ - OsSchedResched(); + OsSchedResched(); // 进行任务切换 - SCHEDULER_UNLOCK(intSave); + SCHEDULER_UNLOCK(intSave); // 释放调度器锁 } STATIC INLINE LOS_DL_LIST *OsSchedLockPendFindPosSub(const LosTaskCB *runTask, const LOS_DL_LIST *lockList) @@ -1151,20 +1194,23 @@ LOS_DL_LIST *OsSchedLockPendFindPos(const LosTaskCB *runTask, LOS_DL_LIST *lockL { LOS_DL_LIST *node = NULL; - if (LOS_ListEmpty(lockList)) { + if (LOS_ListEmpty(lockList)) { // 如果锁的等待队列为空 node = lockList; } else { LosTaskCB *pendedTask1 = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(lockList)); LosTaskCB *pendedTask2 = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_LAST(lockList)); - if (pendedTask1->priority > runTask->priority) { + if (pendedTask1->priority > runTask->priority) { // 如果最高优先级的等待任务的优先级高于当前任务的优先级 node = lockList->pstNext; - } else if (pendedTask2->priority <= runTask->priority) { + } else if (pendedTask2->priority <= runTask->priority) { // 如果最低优先级的等待任务的优先级小于等于当前任务的优先级 node = lockList; } else { - node = OsSchedLockPendFindPosSub(runTask, lockList); + node = OsSchedLockPendFindPosSub(runTask, lockList); // 在等待队列中查找当前任务应该插入的位置 } } return node; } - +/*LOS_Schedule函数用于触发调度器进行任务切换。在函数中,首先判断是否处于中断上下文中, +如果是,则设置调度标志,表示需要进行任务切换,然后返回。接下来,判断当前任务是否可被抢占, +如果不可抢占,则直接返回。然后,获取调度器锁,并更新当前任务的时间片。接着,将当前任务加入就绪队列, +并调用OsSchedResched函数进行任务*/ \ No newline at end of file