/*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 *    conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 *    of conditions and the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "los_sched_pri.h"
#include "los_hw_pri.h"
#include "los_task_pri.h"
#include "los_process_pri.h"
#include "los_arch_mmu.h"
#include "los_hook.h"
#ifdef LOSCFG_KERNEL_CPUP
#include "los_cpup_pri.h"
#endif
#include "los_hw_tick_pri.h"
#include "los_tick_pri.h"
#ifdef LOSCFG_BASE_CORE_TSK_MONITOR
#include "los_stackinfo_pri.h"
#endif
#include "los_mp.h"
#ifdef LOSCFG_SCHED_DEBUG
#include "los_stat_pri.h"
#endif

#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;  // 队列位图
} SchedQueue;
//定义调度器结构体Sched
typedef struct {
    SchedQueue queueList[OS_PRIORITY_QUEUE_NUM];  // 优先级队列列表
    UINT32     queueBitmap;  // 队列位图
    SchedScan  taskScan;   // 任务扫描
    SchedScan  swtmrScan;  // 软件定时器扫描
} Sched;

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  //定义调度器tick调试数据数量的常量
//定义调度器tick调试数据结构体SchedTickDebug
typedef struct {
    UINT32 tickResporeTime[OS_SCHED_DEBUG_DATA_NUM];  // tick响应时间数组
    UINT32 index;  // 当前数据索引
    UINT32 setTickCount;  // 设置的tick计数
    UINT64 oldResporeTime;  // 上一次的响应时间
} SchedTickDebug;
STATIC SchedTickDebug *g_schedTickDebug = NULL;  //定义全局调度器tick调试数据变量g_schedTickDebug

//初始化调度器tick调试数据
STATIC UINT32 OsSchedDebugInit(VOID)
{
    UINT32 size = sizeof(SchedTickDebug) * LOSCFG_KERNEL_CORE_NUM;
    g_schedTickDebug = (SchedTickDebug *)LOS_MemAlloc(m_aucSysMem0, size);
    if (g_schedTickDebug == NULL) {
        return LOS_ERRNO_TSK_NO_MEMORY;
    }

    (VOID)memset_s(g_schedTickDebug, size, 0, size);
    return LOS_OK;
}
//记录调度器tick调试数据
VOID OsSchedDebugRecordData(VOID)
{
    SchedTickDebug *schedDebug = &g_schedTickDebug[ArchCurrCpuid()];
    if (schedDebug->index < OS_SCHED_DEBUG_DATA_NUM) {
        UINT64 currTime = OsGetCurrSchedTimeCycle();
        schedDebug->tickResporeTime[schedDebug->index] = currTime - schedDebug->oldResporeTime;
        schedDebug->oldResporeTime = currTime;
        schedDebug->index++;
    }
}
//获取调度器tick调试数据
SchedTickDebug *OsSchedDebugGet(VOID)
{
    return g_schedTickDebug;
}
// 显示调度器 tick 响应时间的 Shell 命令函数
UINT32 OsShellShowTickRespo(VOID)
{
    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]; // 获取当前 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; // 获取当前 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每行显示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));  //平均响应周期
    }

    // 释放内存
    (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); // 在系统内存池中分配任务控制块数组的内存
    if (taskCBArray == NULL) {
        return LOS_NOK;
    }

    SCHEDULER_LOCK(intSave); // 禁止调度器调度

    // 将全局的任务控制块数组拷贝到局部数组中
    (VOID)memcpy_s(taskCBArray, size, g_taskCBArray, size);

    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; // 获取当前任务控制块

        // 如果任务控制块未使用，则跳过
        if (OsTaskIsUnused(taskCB)) {
            continue;
        }

        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; // 将平均运行时间转换为微秒
        }

        // 计算平均时间片
        if (taskCB->schedStat.timeSliceCount > 1) {
            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; // 将平均挂起时间转换为微秒
        }

        // 计算平均等待调度时间
        if (taskCB->schedStat.waitSchedCount > 0) {
            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); // 释放内存

    return LOS_OK;
}

#else


UINT32 OsShellShowSchedParam(VOID)
{
    return LOS_NOK; // 返回错误码，表示未实现该函数
}
#endif

// 设置调度器的 tick 定时器类型
UINT32 OsSchedSetTickTimerType(UINT32 timerType)
{
    switch (timerType) {
        case 32: /* 32 位定时器 */
            g_schedTickMaxResponseTime = OS_32BIT_MAX; // 设置最大的 tick 响应时间为 32 位定时器的最大值
            break;
        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_OK; // 返回成功码
}

// 设置调度器的启动时间
STATIC VOID OsSchedSetStartTime(UINT64 currCycle)
{
    if (g_sysSchedStartTime == OS_64BIT_MAX) {
        g_sysSchedStartTime = currCycle; // 如果系统的调度启动时间未设置，则设置为当前的时钟周期数
    }
}

// 更新时间片
STATIC INLINE VOID OsTimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime)
{
    LOS_ASSERT(currTime >= taskCB->startTime); // 断言当前时间大于等于任务的启动时间

    INT32 incTime = (currTime - taskCB->startTime - taskCB->irqUsedTime); // 计算增加的时间

    LOS_ASSERT(incTime >= 0); // 断言增加的时间大于等于0

    if (taskCB->policy == LOS_SCHED_RR) {
        taskCB->timeSlice -= incTime; // 更新时间片剩余时间
#ifdef LOSCFG_SCHED_DEBUG
        taskCB->schedStat.timeSliceRealTime += incTime; // 更新调度统计信息中的实际时间片使用时间
#endif
    }
    taskCB->irqUsedTime = 0; // 清零中断使用的时间
    taskCB->startTime = currTime; // 更新任务的启动时间

#ifdef LOSCFG_SCHED_DEBUG
    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(); // 获取当前的调度时间
    if (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; // 减去已经使用的时间，得到下一次 tick 定时器的响应时间
    } else {
        nextResponseTime = OS_TICK_RESPONSE_PRECISION; // 如果计算出的响应时间小于精度要求，设置为精度要求
    }

    nextExpireTime = currTime + nextResponseTime; // 计算下一次 tick 定时器的到期时间
    if (nextExpireTime >= currCpu->responseTime) {
        return; // 如果下一次到期时间大于等于当前的响应时间，直接返回
    }

    if (isTimeSlice) {
        /* 当前系统的到期时间是线程的时间片到期时间 */
        currCpu->responseID = responseID; // 设置当前 CPU 的响应 ID
    } else {
        currCpu->responseID = OS_INVALID_VALUE; // 设置当前 CPU 的响应 ID 为无效值
    }
    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++; // 更新调度 tick 调试信息中的设置 tick 数量
    }
#endif
}


STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID,
                                            UINT64 taskEndTime, UINT32 oldResponseID)
{
    UINT64 nextExpireTime = OsGetNextExpireTime(startTime); // 获取下一次到期时间
    Percpu *currCpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针
    UINT64 nextResponseTime;
    BOOL isTimeSlice = FALSE;

    currCpu->schedFlag &= ~INT_PEND_TICK; // 清除调度标志位中的中断挂起标志

    if (currCpu->responseID == oldResponseID) {
        /* 此次已经到期，下一次理论上到期的时间为无穷大 */
        currCpu->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
    }

    /* 当前线程的时间片已经消耗完，但当前系统锁定任务无法触发调度以释放 CPU */
    if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) {
        nextExpireTime = taskEndTime;
        isTimeSlice = TRUE; // 设置时间片到期标志
    }

    if ((currCpu->responseTime > nextExpireTime) &&
        ((currCpu->responseTime - nextExpireTime) >= OS_TICK_RESPONSE_PRECISION)) {
        nextResponseTime = nextExpireTime - startTime; // 计算下一次响应时间
        if (nextResponseTime > g_schedTickMaxResponseTime) {
            nextResponseTime = g_schedTickMaxResponseTime; // 如果下一次响应时间超过最大响应时间，设置为最大响应时间
        }
    } else {
        /* 没有比当前到期时间更早的点 */
        currCpu->tickStartTime = 0; // 清零 tick 定时器的启动时间
        return;
    }

    OsSchedTickReload(currCpu, nextResponseTime, responseID, isTimeSlice); // 重新加载 tick 定时器
}

VOID OsSchedUpdateExpireTime(UINT64 startTime)
{
    UINT64 endTime;
    Percpu *cpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针
    LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务的控制块指针

    if (!OS_SCHEDULER_ACTIVE || OS_INT_ACTIVE) {
        cpu->schedFlag |= INT_PEND_TICK; // 如果调度器不活跃或者中断活跃，设置调度标志位中的中断挂起标志
        return;
    }

    if (runTask->policy == LOS_SCHED_RR) {
        LOS_SpinLock(&g_taskSpin);
        INT32 timeSlice = (runTask->timeSlice <= OS_TIME_SLICE_MIN) ? runTask->initTimeSlice : runTask->timeSlice;
        LOS_SpinUnlock(&g_taskSpin);
        endTime = startTime + timeSlice; // 计算任务的结束时间
    } else {
        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; // 如果不是轮转调度策略，设置结束时间为最大响应时间减去精度要求
    }

    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]; // 获取指定优先级的就绪任务数量
    if (readTasks > OS_SCHED_READY_MAX) {
        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); // 返回计算出的时间片
}
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; // 获取位图

    /*
     * 任务控制块被初始化为零。当任务被删除时，
     * 同时从优先级队列或其他列表中删除，任务挂起节点将被恢复为零。
     */
    LOS_ASSERT(priqueueItem->pstNext == NULL); // 断言优先级队列项的下一个节点为空

    if (*bitMap == 0) {
        g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; // 如果位图为零，设置全局位图中对应的位
    }

    if (LOS_ListEmpty(&priQueueList[priority])) {
        *bitMap |= PRIQUEUE_PRIOR0_BIT >> 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; // 获取位图

    /*
     * 任务控制块被初始化为零。当任务被删除时，
     * 同时从优先级队列或其他列表中删除，任务挂起节点将被恢复为零。
     */
    LOS_ASSERT(priqueueItem->pstNext == NULL); // 断言优先级队列项的下一个节点为空

    if (*bitMap == 0) {
        g_sched->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> proPriority; // 如果位图为零，设置全局位图中对应的位
    }

    if (LOS_ListEmpty(&priQueueList[priority])) {
        *bitMap |= PRIQUEUE_PRIOR0_BIT >> 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; // 获取位图

    LOS_ListDelete(priqueueItem); // 从优先级队列中删除优先级队列项
    queueList->readyTasks[priority]--; // 减少指定优先级的就绪任务数量
    if (LOS_ListEmpty(&priQueueList[priority])) {
        *bitMap &= ~(PRIQUEUE_PRIOR0_BIT >> priority); // 如果指定优先级的优先级队列为空，清除位图中对应的位
    }

    if (*bitMap == 0) {
        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; // 获取任务的状态
    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); // 清除任务的挂起状态和延时状态
        if (tempStatus & OS_TASK_STATUS_PENDING) {
#ifdef LOSCFG_KERNEL_LITEIPC
            taskCB->ipcStatus &= ~IPC_THREAD_STATUS_PEND; // 清除任务的轻量级 IPC 挂起状态
#endif
            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++; // 增加任务的挂起次数统计
#endif
            OsSchedTaskEnQueue(taskCB); // 将任务加入调度队列
            *needSchedule = TRUE; // 设置需要进行调度
        }
    }

    LOS_SpinUnlock(&g_taskSpin); // 释放全局任务自旋锁
}

STATIC INLINE BOOL OsSchedScanTimerList(VOID)
{
    Percpu *cpu = OsPercpuGet(); // 获取当前 CPU 的 Per-CPU 变量
    BOOL needSchedule = FALSE; // 标记是否需要进行调度
    SortLinkAttribute *taskSortLink = &OsPercpuGet()->taskSortLink; // 获取当前 CPU 的任务排序链表属性
    LOS_DL_LIST *listObject = &taskSortLink->sortLink; // 获取当前 CPU 的任务排序链表
    /*
     * 当任务被挂起并设置了超时时，任务块会同时存在于超时排序链表
     * (每个 CPU 都有一个) 和相应的 IPC（互斥信号量、信号量等）的链表中，
     * 它可以通过超时或等待的 IPC 被唤醒。
     *
     * 现在使用同步的排序链表过程，因此整个任务扫描需要保护，
     * 防止另一个核心同时进行排序链表的删除操作。
     */
    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(); // 获取当前调度时间
    while (sortList->responseTime <= currTime) {
        LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(sortList, LosTaskCB, sortList); // 获取任务控制块
        OsDeleteNodeSortLink(taskSortLink, &taskCB->sortList); // 从排序链表中删除任务节点
        LOS_SpinUnlock(&cpu->taskSortLinkSpin); // 释放当前 CPU 的任务排序链表自旋锁

        OsSchedWakePendTimeTask(currTime, taskCB, &needSchedule); // 唤醒被挂起的超时任务

        LOS_SpinLock(&cpu->taskSortLinkSpin); // 获取当前 CPU 的任务排序链表自旋锁
        if (LOS_ListEmpty(listObject)) {
            break;
        }

        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); // 获取排序链表的下一个任务节点
    }

    LOS_SpinUnlock(&cpu->taskSortLinkSpin); // 释放当前 CPU 的任务排序链表自旋锁

    return needSchedule; // 返回是否需要进行调度
}
STATIC INLINE VOID OsSchedEnTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
{
    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); // 将任务加入就绪队列的头部
            } else {
                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++; // 增加任务的时间片计数
#endif
            }
            break;
        }
        case LOS_SCHED_FIFO: {
            /* 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; // 设置任务的初始时间片为 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; // 设置任务的时间片计数为 1
#endif
            break;
        default:
            LOS_ASSERT(0); // 断言不会执行到这里
            break;
    }

    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++; // 增加进程的就绪任务数
}

STATIC INLINE VOID OsSchedDeTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
{
    if (taskCB->policy != LOS_SCHED_IDLE) { // 如果任务的调度策略不是 IDLE
        OsSchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority); // 从就绪队列中删除任务
    }
    taskCB->taskStatus &= ~OS_TASK_STATUS_READY; // 清除任务的就绪状态

    processCB->readyTaskNum--; // 减少进程的就绪任务数
    if (processCB->readyTaskNum == 0) {
        processCB->processStatus &= ~OS_PROCESS_STATUS_READY; // 如果进程的就绪任务数为 0，则清除进程的就绪状态
    }
}

VOID OsSchedTaskDeQueue(LosTaskCB *taskCB)
{
    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); // 获取任务所属进程的控制块

    if (taskCB->taskStatus & OS_TASK_STATUS_READY) { // 如果任务处于就绪状态
        OsSchedDeTaskQueue(taskCB, processCB); // 从就绪队列中删除任务
    }

    if (processCB->processStatus & OS_PROCESS_STATUS_READY) { // 如果进程处于就绪状态
        return;
    }

    /* 如果当前进程只有当前线程在运行，
     * 那么线程离开调度队列后进程将变为阻塞状态
     */
    if (OS_PROCESS_GET_RUNTASK_COUNT(processCB->processStatus) == 1) {
        processCB->processStatus |= OS_PROCESS_STATUS_PENDING; // 设置进程的挂起状态
    }
}

VOID OsSchedTaskEnQueue(LosTaskCB *taskCB)
{
    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID); // 获取任务所属进程的控制块
#ifdef LOSCFG_SCHED_DEBUG
    if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) { // 如果任务不是正在运行状态
        taskCB->startTime = OsGetCurrSchedTimeCycle(); // 记录任务的启动时间
    }
#endif
    OsSchedEnTaskQueue(taskCB, processCB); // 将任务加入就绪队列
}

VOID OsSchedTaskExit(LosTaskCB *taskCB)
{
    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_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(); // 获取当前运行的任务

    runTask->timeSlice = 0; // 将任务的时间片设置为 0

    runTask->startTime = OsGetCurrSchedTimeCycle(); // 记录任务的启动时间
    OsSchedTaskEnQueue(runTask); // 将任务加入就绪队列
    OsSchedResched(); // 进行调度
}

VOID OsSchedDelay(LosTaskCB *runTask, UINT32 tick)
{
    OsSchedTaskDeQueue(runTask); // 从就绪队列中删除任务
    runTask->taskStatus |= OS_TASK_STATUS_DELAY; // 设置任务的延时状态
    runTask->waitTimes = tick; // 设置任务的等待时间

    OsSchedResched(); // 进行调度
}

UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched)
{
    LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务
    OsSchedTaskDeQueue(runTask); // 从就绪队列中删除任务

    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 (needSched == TRUE) { // 如果需要进行调度
        OsSchedResched(); // 进行调度
        if (runTask->taskStatus & OS_TASK_STATUS_TIMEOUT) { // 如果任务超时
            runTask->taskStatus &= ~OS_TASK_STATUS_TIMEOUT; // 清除任务的超时状态
            return LOS_ERRNO_TSK_TIMEOUT; // 返回超时错误
        }
    }

    return LOS_OK; // 返回成功
}

VOID OsSchedTaskWake(LosTaskCB *resumedTask)
{
    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_SUSPENDED)) { // 如果任务没有被挂起
#ifdef LOSCFG_SCHED_DEBUG
        resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime;
        resumedTask->schedStat.pendCount++;
#endif
        OsSchedTaskEnQueue(resumedTask);
    }
}

BOOL OsSchedModifyTaskSchedParam(LosTaskCB *taskCB, UINT16 policy, UINT16 priority)
{
    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; // 返回需要进行调度
    }

    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; // 返回需要进行调度
    }

    return FALSE; // 返回不需要进行调度
}


BOOL OsSchedModifyProcessSchedParam(LosProcessCB *processCB, UINT16 policy, UINT16 priority)
{
    LosTaskCB *taskCB = NULL;
    BOOL needSched = FALSE;
    (VOID)policy; // 忽略传入的调度策略

    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; // 需要进行调度
            }
        }
    }

    processCB->priority = priority; // 更新进程的优先级
    if (processCB->processStatus & OS_PROCESS_STATUS_RUNNING) { // 如果进程处于运行状态
        needSched = TRUE; // 需要进行调度
    }

    return needSched; // 返回是否需要进行调度
}

VOID OsSchedTick(VOID)
{
    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(); // 执行任务扫描函数，判断是否需要进行调度

        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; // 设置响应时间的上限
}

VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *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; // 返回失败
    }

    g_sched->swtmrScan = func; // 注册软件定时器扫描函数
    return LOS_OK; // 返回成功
}

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; // 返回内存不足错误
    }

    (VOID)memset_s(g_sched, sizeof(Sched), 0, sizeof(Sched)); // 将全局调度器结构体清零

    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 (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); // 初始化软件定时器排序链表的自旋锁
    }

    g_sched->taskScan = OsSchedScanTimerList; // 设置任务扫描函数为默认的定时器扫描函数

#ifdef LOSCFG_SCHED_TICK_DEBUG
    ret = OsSchedDebugInit(); // 初始化调度器的调试功能
    if (ret != LOS_OK) { // 如果初始化失败
        return ret; // 返回错误码
    }
#endif
    return LOS_OK; // 返回成功
}
STATIC LosTaskCB *OsGetTopTask(VOID)
{
    UINT32 priority, processPriority;
    UINT32 bitmap;
    LosTaskCB *newTask = NULL;
    UINT32 processBitmap = g_sched->queueBitmap; // 获取全局调度器的进程位图
#ifdef LOSCFG_KERNEL_SMP
    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) {
#ifdef LOSCFG_KERNEL_SMP
                if (newTask->cpuAffiMask & (1U << cpuid)) { // 如果任务可以在当前 CPU 上运行
#endif
                    goto FIND_TASK; // 跳转到找到任务的位置
#ifdef LOSCFG_KERNEL_SMP
                }
#endif
            }
            bitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - priority - 1)); // 清除已经遍历过的位
        }
        processBitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - processPriority - 1)); // 清除已经遍历过的位
    }

    newTask = OS_TCB_FROM_TID(OsPercpuGet()->idleTaskID); // 如果没有找到任务，则返回空闲任务

FIND_TASK:
    OsSchedDeTaskQueue(newTask, OS_PCB_FROM_PID(newTask->processID)); // 从任务队列中删除任务
    return newTask; // 返回找到的任务
}
VOID OsSchedStart(VOID)
{
    UINT32 cpuid = ArchCurrCpuid(); // 获取当前 CPU 的 ID
    UINT32 intSave;

    SCHEDULER_LOCK(intSave); // 锁住调度器

    if (cpuid == 0) { // 如果是第一个 CPU
        OsTickStart(); // 启动系统时钟中断
    }

    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); // 增加进程的运行任务计数

    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; // 设置任务所在的 CPU
#endif

    OsCurrTaskSet((VOID *)newTask); // 设置当前任务

    /* System start schedule */
    OS_SCHEDULER_SET(cpuid); // 设置调度器标志，表示系统已经开始调度

    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); // 加载任务上下文并开始执行任务
}

#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); // 解锁任务自旋锁

    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 (((UINTPTR)(newTask->stackPointer) <= newTask->topOfStack) ||
        ((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); // 如果不合法，触发异常并打印错误信息
    }
}
#endif

STATIC INLINE VOID OsSchedSwitchCheck(LosTaskCB *runTask, LosTaskCB *newTask)
{
#ifdef LOSCFG_BASE_CORE_TSK_MONITOR
    OsTaskStackCheck(runTask, newTask); // 检查任务栈的合法性
#endif /* LOSCFG_BASE_CORE_TSK_MONITOR */
    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); // 增加新进程的运行任务计数

    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; // 设置新进程的运行状态标志

#ifdef LOSCFG_KERNEL_VM
    if (OsProcessIsUserMode(newProcess)) { // 如果新进程是用户态进程
        LOS_ArchMmuContextSwitch(&newProcess->vmSpace->archMmu); // 切换内存管理单元上下文
    }
#endif

    OsCurrProcessSet(newProcess); // 设置当前进程为新进程
}
STATIC VOID OsSchedTaskSwicth(LosTaskCB *runTask, LosTaskCB *newTask)
{
    UINT64 endTime;

    OsSchedSwitchCheck(runTask, newTask); // 检查任务切换的相关条件

    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; // 设置当前任务的 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); // 进行进程切换
    }

    if (OsProcessIsUserMode(newProcess)) { // 如果新进程是用户态进程
        OsCurrUserTaskSet(newTask->userArea); // 设置当前用户态任务为新任务的用户态区域
    }

#ifdef LOSCFG_KERNEL_CPUP
    OsCpupCycleEndStart(runTask->taskID, newTask->taskID); // 记录当前任务和新任务的 CPU 周期计数
#endif

#ifdef LOSCFG_SCHED_DEBUG
    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; // 如果当前任务是就绪状态，则将新任务的起始时间设置为当前任务的起始时间
    } else {
        /* The currently running task is blocked */
        newTask->startTime = OsGetCurrSchedTimeCycle(); // 如果当前任务是阻塞状态，则将新任务的起始时间设置为当前调度时间
        /* The task is in a blocking state and needs to update its time slice before pend */
        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); // 将当前任务添加到排序链表中
        }
    }

    if (newTask->policy == LOS_SCHED_RR) {
        endTime = newTask->startTime + newTask->timeSlice; // 如果新任务是轮转调度策略，则计算新任务的结束时间
    } else {
        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; // 如果新任务不是轮转调度策略，则设置新任务的结束时间为最大响应时间
    }
    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++; // 增加当前任务的切换次数
#endif
    /* do the task context switch */
    OsTaskSchedule(newTask, runTask); // 进行任务上下文切换
}
/*在切换任务之前，它首先调用OsSchedSwitchCheck函数来检查任务切换的相关条件。然后，它更新当前任务和新任务的运行状态标志，
并进行一些其他操作，如设置当前任务、进行进程切换、设置用户态任务等。接下来，它根据任务的状态更新新任务的起始时间，并设置
下一个任务的到期时间。最后，它调用OsTaskSchedule函数进行任务上下文切换。
*/
VOID OsSchedIrqEndCheckNeedSched(VOID)
{
    Percpu *percpu = OsPercpuGet(); // 获取当前 CPU 的数据结构指针
    LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务

    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; // 清除调度标志

        LOS_SpinLock(&g_taskSpin); // 获取任务自旋锁

        OsSchedTaskEnQueue(runTask); // 将当前任务加入就绪队列

        LosTaskCB *newTask = OsGetTopTask(); // 获取优先级最高的任务
        if (runTask != newTask) { // 如果当前任务不是优先级最高的任务
            OsSchedTaskSwicth(runTask, newTask); // 进行任务切换
            LOS_SpinUnlock(&g_taskSpin); // 释放任务自旋锁
            return;
        }

        LOS_SpinUnlock(&g_taskSpin); // 释放任务自旋锁
    }

    if (percpu->schedFlag & INT_PEND_TICK) { // 如果有时钟中断挂起
        OsSchedUpdateExpireTime(runTask->startTime); // 更新任务的到期时间
    }
}

VOID OsSchedResched(VOID)
{
    LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); // 断言任务自旋锁已持有
#ifdef LOSCFG_KERNEL_SMP
    LOS_ASSERT(OsPercpuGet()->taskLockCnt == 1); // 断言任务锁计数为1
#else
    LOS_ASSERT(OsPercpuGet()->taskLockCnt == 0); // 断言任务锁计数为0
#endif

    OsPercpuGet()->schedFlag &= ~INT_PEND_RESCH; // 清除调度标志
    LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务
    LosTaskCB *newTask = OsGetTopTask(); // 获取优先级最高的任务
    if (runTask == newTask) { // 如果当前任务就是优先级最高的任务
        return;
    }

    OsSchedTaskSwicth(runTask, newTask); // 进行任务切换
}
/*这段代码实现了在中断结束时检查是否需要进行任务切换的函数OsSchedIrqEndCheckNeedSched，
以及在调度器需要重新调度时执行任务切换的函数OsSchedResched。

OsSchedIrqEndCheckNeedSched函数首先更新当前任务的时间片，并检查当前任务的时间片是否小于
等于最小时间片。如果是，则设置调度标志，表示需要进行任务切换。然后，它检查是否可以抢占且
调度标志已被设置。如果满足条件，则获取任务自旋锁，并将当前任务加入就绪队列。接下来，它获
取优先级最高的任务，如果当前任务不是优先级最高的任务，则进行任务切换，并释放任务自旋锁。
最后，如果有时钟中断挂起，它更新任务的到期时间。

OsSchedResched函数首先断言任务自旋锁已持有，并根据配置选项判断任务锁计数是否为1（SMP）
或者为0（非SMP）。然后，它清除调度标志，并获取当前运行的任务和优先级最高的任务。如果当前
任务就是优先级最高的任务，则直接返回。否则，它进行任务切换。*/

VOID LOS_Schedule(VOID)
{
    UINT32 intSave;
    LosTaskCB *runTask = OsCurrTaskGet(); // 获取当前运行的任务

    if (OS_INT_ACTIVE) { // 如果处于中断上下文
        OsPercpuGet()->schedFlag |= INT_PEND_RESCH; // 设置调度标志，表示需要进行任务切换
        return;
    }

    if (!OsPreemptable()) { // 如果不允许抢占
        return;
    }

    /*
     * trigger schedule in task will also do the slice check
     * if necessary, it will give up the timeslice more in time.
     * otherwise, there's no other side effects.
     */
    SCHEDULER_LOCK(intSave); // 获取调度器锁，禁止调度器抢占

    OsTimeSliceUpdate(runTask, OsGetCurrSchedTimeCycle()); // 更新当前任务的时间片

    /* add run task back to ready queue */
    OsSchedTaskEnQueue(runTask); // 将当前任务加入就绪队列

    /* reschedule to new thread */
    OsSchedResched(); // 进行任务切换

    SCHEDULER_UNLOCK(intSave); // 释放调度器锁
}

STATIC INLINE LOS_DL_LIST *OsSchedLockPendFindPosSub(const LosTaskCB *runTask, const LOS_DL_LIST *lockList)
{
    LosTaskCB *pendedTask = NULL;
    LOS_DL_LIST *node = NULL;

    LOS_DL_LIST_FOR_EACH_ENTRY(pendedTask, lockList, LosTaskCB, pendList) {
        if (pendedTask->priority < runTask->priority) {
            continue;
        } else if (pendedTask->priority > runTask->priority) {
            node = &pendedTask->pendList;
            break;
        } else {
            node = pendedTask->pendList.pstNext;
            break;
        }
    }

    return node;
}

LOS_DL_LIST *OsSchedLockPendFindPos(const LosTaskCB *runTask, LOS_DL_LIST *lockList)
{
    LOS_DL_LIST *node = NULL;

    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) { // 如果最高优先级的等待任务的优先级高于当前任务的优先级
            node = lockList->pstNext;
        } else if (pendedTask2->priority <= runTask->priority) { // 如果最低优先级的等待任务的优先级小于等于当前任务的优先级
            node = lockList;
        } else {
            node = OsSchedLockPendFindPosSub(runTask, lockList); // 在等待队列中查找当前任务应该插入的位置
        }
    }

    return node;
}
/*LOS_Schedule函数用于触发调度器进行任务切换。在函数中，首先判断是否处于中断上下文中，
如果是，则设置调度标志，表示需要进行任务切换，然后返回。接下来，判断当前任务是否可被抢占，
如果不可抢占，则直接返回。然后，获取调度器锁，并更新当前任务的时间片。接着，将当前任务加入就绪队列，
并调用OsSchedResched函数进行任务*/