feat: swtmr机制与调度分离，调度只针对通用线程，不针对特殊功能

背景：
原调度机制与软件定时器实现混合，调度时间链表存在两个链表，
任务切换时需要遍历两个链表才可以获取到最终的tick响应时间。
软件定时作为一个独立的功能，不应该和调度强耦合，而且软件定时
器作为一个任务，某个软件定时器的响应时间应该是软件定时器任务的
响应时间，不应该直接做为tick中断的响应时间。

方案描述：
1.将软件定时器从调度分离，作为一个独立的机制，从调度角度看其就是一个任务
2.软件定时器从调度分离之后，其timelist遍历从tick中断移动至软件定时器任务中
3.优化软件定时器的均衡调度

优势：
1.将软件定时器与调度完全分离，使得调度功能单一化，便于后续其它调度算法的引入
2.优化tick中断，减小tick中断耗时
3.优化通过写队列唤醒软件定时器任务去执行软件定时器钩子为插队列，减少软件定时
器机制本身的耗时，提升软件定时器的实时性
4.优化软件定时器均衡调度，使得软件定时器均匀分布于多核，提升软件定时器的实时性
Signed-off-by: Nzhushengle <zhushengle@huawei.com>
Change-Id: I07c01f134e69c1d9b7061ddf5a231df1ee99b68e

arch/arm/arm/src/include/los_hwi_pri.h

@@ -55,8 +55,8 @@ extern "C" {
 #define HWI_IS_REGISTED(num)             ((&g_hwiForm[num])->pstNext != NULL)
 #endif
 extern VOID OsHwiInit(VOID);
-extern VOID OsIncHwiFormCnt(UINT16 cpuId, UINT32 index);
-extern UINT32 OsGetHwiFormCnt(UINT16 cpuId, UINT32 index);
+extern VOID OsIncHwiFormCnt(UINT16 cpuid, UINT32 index);
+extern UINT32 OsGetHwiFormCnt(UINT16 cpuid, UINT32 index);
 extern CHAR *OsGetHwiFormName(UINT32 index);
 extern VOID OsInterrupt(UINT32 intNum);
 extern VOID OsSyscallHandleInit(VOID);

arch/arm/arm/src/los_exc.c

@@ -74,7 +74,7 @@
 
 STATIC UINTPTR g_minAddr;
 STATIC UINTPTR g_maxAddr;
-STATIC UINT32 g_currHandleExcCpuID = INVALID_CPUID;
+STATIC UINT32 g_currHandleExcCpuid = INVALID_CPUID;
 VOID OsExcHook(UINT32 excType, ExcContext *excBufAddr, UINT32 far, UINT32 fsr);
 UINT32 g_curNestCount[LOSCFG_KERNEL_CORE_NUM] = { 0 };
 BOOL g_excFromUserMode[LOSCFG_KERNEL_CORE_NUM];
@@ -112,11 +112,11 @@ STATIC const StackInfo g_excStack[] = {
 UINT32 OsGetSystemStatus(VOID)
 {
     UINT32 flag;
-    UINT32 cpuID = g_currHandleExcCpuID;
+    UINT32 cpuid = g_currHandleExcCpuid;
 
-    if (cpuID == INVALID_CPUID) {
+    if (cpuid == INVALID_CPUID) {
         flag = OS_SYSTEM_NORMAL;
-    } else if (cpuID == ArchCurrCpuid()) {
+    } else if (cpuid == ArchCurrCpuid()) {
         flag = OS_SYSTEM_EXC_CURR_CPU;
     } else {
         flag = OS_SYSTEM_EXC_OTHER_CPU;
@@ -531,11 +531,11 @@ VOID OsDumpContextMem(const ExcContext *excBufAddr)
 
 STATIC VOID OsExcRestore(VOID)
 {
-    UINT32 currCpuID = ArchCurrCpuid();
+    UINT32 currCpuid = ArchCurrCpuid();
 
-    g_excFromUserMode[currCpuID] = FALSE;
-    g_intCount[currCpuID] = 0;
-    g_curNestCount[currCpuID] = 0;
+    g_excFromUserMode[currCpuid] = FALSE;
+    g_intCount[currCpuid] = 0;
+    g_curNestCount[currCpuid] = 0;
 #ifdef LOSCFG_KERNEL_SMP
     OsCpuStatusSet(CPU_RUNNING);
 #endif
@@ -556,15 +556,15 @@ STATIC VOID OsUserExcHandle(ExcContext *excBufAddr)
 #ifdef LOSCFG_KERNEL_SMP
     LOS_SpinLock(&g_excSerializerSpin);
     if (g_nextExcWaitCpu != INVALID_CPUID) {
-        g_currHandleExcCpuID = g_nextExcWaitCpu;
+        g_currHandleExcCpuid = g_nextExcWaitCpu;
         g_nextExcWaitCpu = INVALID_CPUID;
     } else {
-        g_currHandleExcCpuID = INVALID_CPUID;
+        g_currHandleExcCpuid = INVALID_CPUID;
     }
     g_currHandleExcPID = OS_INVALID_VALUE;
     LOS_SpinUnlock(&g_excSerializerSpin);
 #else
-    g_currHandleExcCpuID = INVALID_CPUID;
+    g_currHandleExcCpuid = INVALID_CPUID;
 #endif
 
 #ifdef LOSCFG_KERNEL_SMP
@@ -979,14 +979,14 @@ VOID OsDataAbortExcHandleEntry(ExcContext *excBufAddr)
 #define EXC_WAIT_INTER 50U
 #define EXC_WAIT_TIME  2000U
 
-STATIC VOID WaitAllCpuStop(UINT32 cpuID)
+STATIC VOID WaitAllCpuStop(UINT32 cpuid)
 {
     UINT32 i;
     UINT32 time = 0;
 
     while (time < EXC_WAIT_TIME) {
         for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
-            if ((i != cpuID) && !OsCpuStatusIsHalt(i)) {
+            if ((i != cpuid) && !OsCpuStatusIsHalt(i)) {
                 LOS_Mdelay(EXC_WAIT_INTER);
                 time += EXC_WAIT_INTER;
                 break;
@@ -1000,19 +1000,19 @@ STATIC VOID WaitAllCpuStop(UINT32 cpuID)
     return;
 }
 
-STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuID)
+STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuid)
 {
     while (1) {
         LOS_SpinLock(&g_excSerializerSpin);
-        if ((g_currHandleExcCpuID == INVALID_CPUID) || (g_currHandleExcCpuID == currCpuID)) {
-            g_currHandleExcCpuID = currCpuID;
+        if ((g_currHandleExcCpuid == INVALID_CPUID) || (g_currHandleExcCpuid == currCpuid)) {
+            g_currHandleExcCpuid = currCpuid;
             g_currHandleExcPID = OsCurrProcessGet()->processID;
             LOS_SpinUnlock(&g_excSerializerSpin);
             break;
         }
 
         if (g_nextExcWaitCpu == INVALID_CPUID) {
-            g_nextExcWaitCpu = currCpuID;
+            g_nextExcWaitCpu = currCpuid;
         }
         LOS_SpinUnlock(&g_excSerializerSpin);
         LOS_Mdelay(EXC_WAIT_INTER);
@@ -1021,7 +1021,7 @@ STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuID)
 
 STATIC VOID OsCheckAllCpuStatus(VOID)
 {
-    UINT32 currCpuID = ArchCurrCpuid();
+    UINT32 currCpuid = ArchCurrCpuid();
     UINT32 ret, target;
 
     OsCpuStatusSet(CPU_EXC);
@@ -1029,17 +1029,17 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
 
     LOS_SpinLock(&g_excSerializerSpin);
     /* Only the current CPU anomaly */
-    if (g_currHandleExcCpuID == INVALID_CPUID) {
-        g_currHandleExcCpuID = currCpuID;
+    if (g_currHandleExcCpuid == INVALID_CPUID) {
+        g_currHandleExcCpuid = currCpuid;
         g_currHandleExcPID = OsCurrProcessGet()->processID;
         LOS_SpinUnlock(&g_excSerializerSpin);
 #ifndef LOSCFG_SAVE_EXCINFO
-        if (g_excFromUserMode[currCpuID] == FALSE) {
-            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuID));
+        if (g_excFromUserMode[currCpuid] == FALSE) {
+            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
             HalIrqSendIpi(target, LOS_MP_IPI_HALT);
         }
 #endif
-    } else if (g_excFromUserMode[currCpuID] == TRUE) {
+    } else if (g_excFromUserMode[currCpuid] == TRUE) {
         /* Both cores raise exceptions, and the current core is a user-mode exception.
          * Both cores are abnormal and come from the same process
          */
@@ -1051,12 +1051,12 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
         }
         LOS_SpinUnlock(&g_excSerializerSpin);
 
-        OsWaitOtherCoresHandleExcEnd(currCpuID);
+        OsWaitOtherCoresHandleExcEnd(currCpuid);
     } else {
-        if ((g_currHandleExcCpuID < LOSCFG_KERNEL_CORE_NUM) && (g_excFromUserMode[g_currHandleExcCpuID] == TRUE)) {
-            g_currHandleExcCpuID = currCpuID;
+        if ((g_currHandleExcCpuid < LOSCFG_KERNEL_CORE_NUM) && (g_excFromUserMode[g_currHandleExcCpuid] == TRUE)) {
+            g_currHandleExcCpuid = currCpuid;
             LOS_SpinUnlock(&g_excSerializerSpin);
-            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuID));
+            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
             HalIrqSendIpi(target, LOS_MP_IPI_HALT);
         } else {
             LOS_SpinUnlock(&g_excSerializerSpin);
@@ -1066,7 +1066,7 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
 #ifndef LOSCFG_SAVE_EXCINFO
     /* use halt ipi to stop other active cores */
     if (g_excFromUserMode[ArchCurrCpuid()] == FALSE) {
-        WaitAllCpuStop(currCpuID);
+        WaitAllCpuStop(currCpuid);
     }
 #endif
 }
@@ -1077,7 +1077,7 @@ STATIC VOID OsCheckCpuStatus(VOID)
 #ifdef LOSCFG_KERNEL_SMP
     OsCheckAllCpuStatus();
 #else
-    g_currHandleExcCpuID = ArchCurrCpuid();
+    g_currHandleExcCpuid = ArchCurrCpuid();
 #endif
 }
 

arch/arm/arm/src/los_hwi.c

@@ -48,9 +48,9 @@ HwiHandleForm g_hwiForm[OS_HWI_MAX_NUM];
 STATIC CHAR *g_hwiFormName[OS_HWI_MAX_NUM] = {0};
 STATIC UINT32 g_hwiFormCnt[LOSCFG_KERNEL_CORE_NUM][OS_HWI_MAX_NUM] = {0};
 
-UINT32 OsGetHwiFormCnt(UINT16 cpuId, UINT32 index)
+UINT32 OsGetHwiFormCnt(UINT16 cpuid, UINT32 index)
 {
-    return g_hwiFormCnt[cpuId][index];
+    return g_hwiFormCnt[cpuid][index];
 }
 
 CHAR *OsGetHwiFormName(UINT32 index)
@@ -69,14 +69,14 @@ VOID OsInterrupt(UINT32 intNum)
 {
     HwiHandleForm *hwiForm = NULL;
     UINT32 *intCnt = NULL;
-    UINT16 cpuId = ArchCurrCpuid();
+    UINT16 cpuid = ArchCurrCpuid();
 
     /* Must keep the operation at the beginning of the interface */
-    intCnt = &g_intCount[cpuId];
+    intCnt = &g_intCount[cpuid];
     *intCnt = *intCnt + 1;
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqStart(cpuId);
+    OsCpupIrqStart(cpuid);
 #endif
 
     OsSchedIrqStartTime();
@@ -101,13 +101,13 @@ VOID OsInterrupt(UINT32 intNum)
 #ifndef LOSCFG_NO_SHARED_IRQ
     }
 #endif
-    ++g_hwiFormCnt[cpuId][intNum];
+    ++g_hwiFormCnt[cpuid][intNum];
 
     OsHookCall(LOS_HOOK_TYPE_ISR_EXIT, intNum);
     OsSchedIrqUpdateUsedTime();
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqEnd(cpuId, intNum);
+    OsCpupIrqEnd(cpuid, intNum);
 #endif
     /* Must keep the operation at the end of the interface */
     *intCnt = *intCnt - 1;

kernel/base/core/los_task.c

@@ -925,7 +925,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
     }
 
     SCHEDULER_LOCK(intSave);
-    OsSchedDelay(runTask, tick);
+    OsSchedDelay(runTask, OS_SCHED_TICK_TO_CYCLE(tick));
     OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, runTask);
     SCHEDULER_UNLOCK(intSave);
 

kernel/base/include/los_sched_pri.h

@@ -48,6 +48,7 @@
 #ifdef LOSCFG_KERNEL_LITEIPC
 #include "hm_liteipc.h"
 #endif
+#include "los_mp.h"
 
 #ifdef __cplusplus
 #if __cplusplus
@@ -57,7 +58,9 @@ extern "C" {
 
 #define OS_SCHED_MINI_PERIOD          (OS_SYS_CLOCK / LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI)
 #define OS_TICK_RESPONSE_PRECISION    (UINT32)((OS_SCHED_MINI_PERIOD * 75) / 100)
-#define OS_SCHED_MAX_RESPONSE_TIME (UINT64)(((UINT64)-1) - 1U)
+#define OS_SCHED_MAX_RESPONSE_TIME    OS_SORT_LINK_INVALID_TIME
+#define OS_SCHED_TICK_TO_CYCLE(ticks) ((UINT64)ticks * OS_CYCLE_PER_TICK)
+#define AFFI_MASK_TO_CPUID(mask)      ((UINT16)((mask) - 1))
 
 extern UINT32 g_taskScheduled;
 #define OS_SCHEDULER_ACTIVE (g_taskScheduled & (1U << ArchCurrCpuid()))
@@ -78,18 +81,17 @@ typedef enum {
 
 typedef struct {
     SortLinkAttribute taskSortLink;          /* task sort link */
-    SortLinkAttribute swtmrSortLink;         /* swtmr sort link */
     UINT64            responseTime;          /* Response time for current CPU tick interrupts */
     UINT32            responseID;            /* The response ID of the current CPU tick interrupt */
     UINT32            idleTaskID;            /* idle task id */
     UINT32            taskLockCnt;           /* task lock flag */
-    UINT32            swtmrTaskID;           /* software timer task id */
-    UINT32            swtmrHandlerQueue;     /* software timer timeout queue id */
     UINT32            schedFlag;             /* pending scheduler flag */
 } SchedRunQue;
 
 extern SchedRunQue g_schedRunQue[LOSCFG_KERNEL_CORE_NUM];
 
+VOID OsSchedUpdateExpireTime(VOID);
+
 STATIC INLINE SchedRunQue *OsSchedRunQue(VOID)
 {
     return &g_schedRunQue[ArchCurrCpuid()];
@@ -190,75 +192,8 @@ STATIC INLINE VOID OsSchedRunQuePendingSet(VOID)
     OsSchedRunQue()->schedFlag |= INT_PEND_RESCH;
 }
 
-#ifdef LOSCFG_KERNEL_SMP
-STATIC INLINE VOID FindIdleRunQue(UINT16 *idleCpuID)
-{
-    SchedRunQue *idleRq = OsSchedRunQueByID(0);
-    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->taskSortLink) + OsGetSortLinkNodeNum(&idleRq->swtmrSortLink);
-    UINT16 cpuID = 1;
-    do {
-        SchedRunQue *rq = OsSchedRunQueByID(cpuID);
-        UINT32 temp = OsGetSortLinkNodeNum(&rq->taskSortLink) + OsGetSortLinkNodeNum(&rq->swtmrSortLink);
-        if (nodeNum > temp) {
-            *idleCpuID = cpuID;
-            nodeNum = temp;
-        }
-        cpuID++;
-    } while (cpuID < LOSCFG_KERNEL_CORE_NUM);
-}
-#endif
-
-STATIC INLINE VOID OsSchedAddTask2TimeList(SortLinkList *node, UINT64 startTime, UINT32 waitTicks)
-{
-    UINT16 idleCpu = 0;
-#ifdef LOSCFG_KERNEL_SMP
-    FindIdleRunQue(&idleCpu);
-#endif
-    SchedRunQue *rq = OsSchedRunQueByID(idleCpu);
-    UINT64 responseTime = startTime + (UINT64)waitTicks * OS_CYCLE_PER_TICK;
-    OsAdd2SortLink(&rq->taskSortLink, node, responseTime, idleCpu);
-}
-
-STATIC INLINE UINT32 OsSchedSwtmrHandlerQueueGet(VOID)
-{
-    return OsSchedRunQue()->swtmrHandlerQueue;
-}
-
-STATIC INLINE VOID OsSchedDeTaskFromTimeList(SortLinkList *node)
-{
-#ifdef LOSCFG_KERNEL_SMP
-    SchedRunQue *rq = OsSchedRunQueByID(node->cpuid);
-#else
-    SchedRunQue *rq = OsSchedRunQueByID(0);
-#endif
-    OsDeleteFromSortLink(&rq->taskSortLink, node);
-}
-
-STATIC INLINE VOID OsSchedAddSwtmr2TimeList(SortLinkList *node, UINT64 startTime, UINT32 waitTicks)
-{
-    UINT16 idleCpu = 0;
-#ifdef LOSCFG_KERNEL_SMP
-    FindIdleRunQue(&idleCpu);
-#endif
-    SchedRunQue *rq = OsSchedRunQueByID(idleCpu);
-    UINT64 responseTime = startTime + (UINT64)waitTicks * OS_CYCLE_PER_TICK;
-    OsAdd2SortLink(&rq->swtmrSortLink, node, responseTime, idleCpu);
-}
-
-STATIC INLINE VOID OsSchedDeSwtmrFromTimeList(SortLinkList *node)
-{
-#ifdef LOSCFG_KERNEL_SMP
-    SchedRunQue *rq = OsSchedRunQueByID(node->cpuid);
-#else
-    SchedRunQue *rq = OsSchedRunQueByID(0);
-#endif
-    OsDeleteFromSortLink(&rq->swtmrSortLink, node);
-}
-
 VOID OsSchedRunQueIdleInit(UINT32 idleTaskID);
-VOID OsSchedRunQueSwtmrInit(UINT32 swtmrTaskID, UINT32 swtmrQueue);
 VOID OsSchedRunQueInit(VOID);
-BOOL OsSchedSwtmrTimeListFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 
 /**
  * @ingroup los_sched
@@ -359,11 +294,11 @@ typedef struct {
     UINT16          priority;           /**< Task priority */
     UINT16          policy;
     UINT64          startTime;          /**< The start time of each phase of task */
+    UINT64          waitTime;           /**< Task delay time, tick number */
     UINT64          irqStartTime;       /**< Interrupt start time */
     UINT32          irqUsedTime;        /**< Interrupt consumption time */
     UINT32          initTimeSlice;      /**< Task init time slice */
     INT32           timeSlice;          /**< Task remaining time slice */
-    UINT32          waitTimes;          /**< Task delay time, tick number */
     SortLinkList    sortList;           /**< Task sortlink node */
 
     UINT32          stackSize;          /**< Task stack size */
@@ -480,6 +415,78 @@ STATIC INLINE VOID OsSchedIrqStartTime(VOID)
     runTask->irqStartTime = OsGetCurrSchedTimeCycle();
 }
 
+#ifdef LOSCFG_KERNEL_SMP
+STATIC INLINE VOID FindIdleRunQue(UINT16 *idleCpuid)
+{
+    SchedRunQue *idleRq = OsSchedRunQueByID(0);
+    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->taskSortLink);
+    UINT16 cpuid = 1;
+    do {
+        SchedRunQue *rq = OsSchedRunQueByID(cpuid);
+        UINT32 temp = OsGetSortLinkNodeNum(&rq->taskSortLink);
+        if (nodeNum > temp) {
+            *idleCpuid = cpuid;
+            nodeNum = temp;
+        }
+        cpuid++;
+    } while (cpuid < LOSCFG_KERNEL_CORE_NUM);
+}
+#endif
+
+STATIC INLINE VOID OsSchedAddTask2TimeList(LosTaskCB *taskCB, UINT64 responseTime)
+{
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16 cpuid = AFFI_MASK_TO_CPUID(taskCB->cpuAffiMask);
+    if (cpuid >= LOSCFG_KERNEL_CORE_NUM) {
+        cpuid = 0;
+        FindIdleRunQue(&cpuid);
+    }
+#else
+    UINT16 cpuid = 0;
+#endif
+
+    SchedRunQue *rq = OsSchedRunQueByID(cpuid);
+    OsAdd2SortLink(&rq->taskSortLink, &taskCB->sortList, responseTime, cpuid);
+#ifdef LOSCFG_KERNEL_SMP
+    if ((cpuid != ArchCurrCpuid()) && (responseTime < rq->responseTime)) {
+        rq->schedFlag |= INT_PEND_TICK;
+        LOS_MpSchedule(CPUID_TO_AFFI_MASK(cpuid));
+    }
+#endif
+}
+
+STATIC INLINE VOID OsSchedDeTaskFromTimeList(LosTaskCB *taskCB)
+{
+    SortLinkList *node = &taskCB->sortList;
+#ifdef LOSCFG_KERNEL_SMP
+    SchedRunQue *rq = OsSchedRunQueByID(node->cpuid);
+#else
+    SchedRunQue *rq = OsSchedRunQueByID(0);
+#endif
+    UINT64 oldResponseTime = GET_SORTLIST_VALUE(node);
+    OsDeleteFromSortLink(&rq->taskSortLink, node);
+    if (oldResponseTime <= rq->responseTime) {
+        rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
+    }
+}
+
+STATIC INLINE UINT32 OsSchedAdjustTaskFromTimeList(LosTaskCB *taskCB, UINT64 responseTime)
+{
+    UINT32 ret;
+    SortLinkList *node = &taskCB->sortList;
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16 cpuid = node->cpuid;
+#else
+    UINT16 cpuid = 0;
+#endif
+    SchedRunQue *rq = OsSchedRunQueByID(cpuid);
+    ret = OsSortLinkAdjustNodeResponseTime(&rq->taskSortLink, node, responseTime);
+    if (ret == LOS_OK) {
+        rq->schedFlag |= INT_PEND_TICK;
+    }
+    return ret;
+}
+
 /*
  * Schedule flag, one bit represents one core.
  * This flag is used to prevent kernel scheduling before OSStartToRun.
@@ -494,7 +501,6 @@ STATIC INLINE VOID OsSchedIrqStartTime(VOID)
 
 VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask);
 VOID OsSchedResetSchedResponseTime(UINT64 responseTime);
-VOID OsSchedUpdateExpireTime(VOID);
 VOID OsSchedToUserReleaseLock(VOID);
 VOID OsSchedTaskDeQueue(LosTaskCB *taskCB);
 VOID OsSchedTaskEnQueue(LosTaskCB *taskCB);
@@ -504,7 +510,7 @@ BOOL OsSchedModifyTaskSchedParam(LosTaskCB *taskCB, UINT16 policy, UINT16 priori
 BOOL OsSchedModifyProcessSchedParam(UINT32 pid, UINT16 policy, UINT16 priority);
 VOID OsSchedSuspend(LosTaskCB *taskCB);
 BOOL OsSchedResume(LosTaskCB *taskCB);
-VOID OsSchedDelay(LosTaskCB *runTask, UINT32 tick);
+VOID OsSchedDelay(LosTaskCB *runTask, UINT64 waitTime);
 VOID OsSchedYield(VOID);
 VOID OsSchedTaskExit(LosTaskCB *taskCB);
 VOID OsSchedTick(VOID);
@@ -525,14 +531,13 @@ VOID OsSchedIrqEndCheckNeedSched(VOID);
 */
 LOS_DL_LIST *OsSchedLockPendFindPos(const LosTaskCB *runTask, LOS_DL_LIST *lockList);
 
+#ifdef LOSCFG_SCHED_DEBUG
 #ifdef LOSCFG_SCHED_TICK_DEBUG
 VOID OsSchedDebugRecordData(VOID);
 #endif
-
 UINT32 OsShellShowTickRespo(VOID);
-
 UINT32 OsShellShowSchedParam(VOID);
-
+#endif
 #ifdef __cplusplus
 #if __cplusplus
 }

kernel/base/include/los_sortlink_pri.h

@@ -72,28 +72,42 @@ STATIC INLINE UINT64 OsGetSortLinkNextExpireTime(SortLinkAttribute *sortHeader,
     LOS_DL_LIST *head = &sortHeader->sortLink;
     LOS_DL_LIST *list = head->pstNext;
 
+    LOS_SpinLock(&sortHeader->spinLock);
     if (LOS_ListEmpty(head)) {
+        LOS_SpinUnlock(&sortHeader->spinLock);
         return OS_SORT_LINK_INVALID_TIME - tickPrecision;
     }
 
     SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
     if (listSorted->responseTime <= (startTime + tickPrecision)) {
+        LOS_SpinUnlock(&sortHeader->spinLock);
         return startTime + tickPrecision;
     }
 
+    LOS_SpinUnlock(&sortHeader->spinLock);
     return listSorted->responseTime;
 }
 
-STATIC INLINE UINT32 OsGetSortLinkNodeNum(SortLinkAttribute *head)
+STATIC INLINE UINT32 OsGetSortLinkNodeNum(const SortLinkAttribute *head)
 {
     return head->nodeNum;
 }
 
+STATIC INLINE UINT16 OsGetSortLinkNodeCpuid(const SortLinkList *node)
+{
+#ifdef LOSCFG_KERNEL_SMP
+    return node->cpuid;
+#else
+    return 0;
+#endif
+}
+
 VOID OsSortLinkInit(SortLinkAttribute *sortLinkHeader);
 VOID OsAdd2SortLink(SortLinkAttribute *head, SortLinkList *node, UINT64 responseTime, UINT16 idleCpu);
 VOID OsDeleteFromSortLink(SortLinkAttribute *head, SortLinkList *node);
 UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList);
 UINT64 OsSortLinkGetNextExpireTime(UINT64 currTime, const SortLinkAttribute *sortLinkHeader);
+UINT32 OsSortLinkAdjustNodeResponseTime(SortLinkAttribute *head, SortLinkList *node, UINT64 responseTime);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/include/los_swtmr_pri.h

@@ -66,8 +66,9 @@ typedef struct {
     SWTMR_PROC_FUNC handler;    /**< Callback function that handles software timer timeout  */
     UINTPTR arg;                /**< Parameter passed in when the callback function
                                      that handles software timer timeout is called */
+    LOS_DL_LIST node;
 #ifdef LOSCFG_SWTMR_DEBUG
-    UINT32 swtmrId;
+    UINT32 swtmrID;
 #endif
 } SwtmrHandlerItem;
 
@@ -103,13 +104,14 @@ extern SWTMR_CTRL_S *g_swtmrCBArray;
  * @see LOS_SwtmrStop
  */
 
+extern UINT32 OsSwtmrGetNextTimeout(VOID);
 extern BOOL OsIsSwtmrTask(const LosTaskCB *taskCB);
-extern VOID OsSwtmrRestart(UINT64 startTime, SortLinkList *sortList);
-extern VOID OsSwtmrWake(SchedRunQue *rq, UINT64 currTime, SortLinkList *sortList);
+extern VOID OsSwtmrResponseTimeReset(UINT64 startTime);
 extern UINT32 OsSwtmrInit(VOID);
 extern VOID OsSwtmrRecycle(UINT32 processID);
 extern BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 extern SPIN_LOCK_S g_swtmrSpin;
+extern UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid);
 
 #ifdef LOSCFG_SWTMR_DEBUG
 typedef struct {
@@ -123,9 +125,14 @@ typedef struct {
     UINT64 runTime;
     UINT64 runTimeMax;
     UINT64 runCount;
+    UINT32 times;
+} SwtmrDebugBase;
+
+typedef struct {
+    SwtmrDebugBase  base;
     SWTMR_PROC_FUNC handler;
     UINT32          period;
-    UINT32          cpuId;
+    UINT32          cpuid;
     BOOL            swtmrUsed;
 } SwtmrDebugData;
 

kernel/base/misc/swtmr_shellcmd.c

@@ -116,8 +116,8 @@ STATIC VOID OsSwtmrTimeInfoShow(VOID)
     UINT8 mode;
     SwtmrDebugData data;
 
-    PRINTK("SwtmrID  CpuId   Mode    Period(us) WaitTime(us) WaitMax(us) RTime(us) RTimeMax(us) ReTime(us)"
-           " ReTimeMax(us)      RunCount     Handler\n");
+    PRINTK("SwtmrID  Cpuid   Mode    Period(us) WaitTime(us) WaitMax(us) RTime(us) RTimeMax(us) ReTime(us)"
+           " ReTimeMax(us)      RunCount    LostNum     Handler\n");
     for (UINT32 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
         if (!OsSwtmrDebugDataUsed(index)) {
             continue;
@@ -128,15 +128,16 @@ STATIC VOID OsSwtmrTimeInfoShow(VOID)
             break;
         }
 
-        UINT64 waitTime = ((data.waitTime / data.waitCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        UINT64 waitTimeMax = (data.waitTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        UINT64 runTime = ((data.runTime / data.runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        UINT64 runTimeMax = (data.runTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        UINT64 readyTime = ((data.readyTime / data.runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        UINT64 readyTimeMax = (data.readyTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
-        PRINTK("%4u%10u%7s%14u%13llu%12llu%10llu%13llu%10llu%14llu%15llu%#12x\n",
-               index, data.cpuId, g_shellSwtmrMode[mode], data.period * OS_US_PER_TICK, waitTime, waitTimeMax,
-               runTime, runTimeMax, readyTime, readyTimeMax, data.runCount, data.handler);
+        SwtmrDebugBase *base = &data.base;
+        UINT64 waitTime = ((base->waitTime / base->waitCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 waitTimeMax = (base->waitTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 runTime = ((base->runTime / base->runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 runTimeMax = (base->runTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 readyTime = ((base->readyTime / base->runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 readyTimeMax = (base->readyTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        PRINTK("%4u%10u%7s%14u%13llu%12llu%10llu%13llu%10llu%14llu%15llu%11u%#12x\n",
+               index, data.cpuid, g_shellSwtmrMode[mode], data.period * OS_US_PER_TICK, waitTime, waitTimeMax,
+               runTime, runTimeMax, readyTime, readyTimeMax, base->runCount, base->times, data.handler);
     }
 }
 #endif

kernel/base/sched/sched_sq/los_sched.c

@@ -59,7 +59,6 @@
 #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_TASK_STATUS_BLOCKED     (OS_TASK_STATUS_INIT | OS_TASK_STATUS_PENDING | \
                                     OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)
 
@@ -133,7 +132,7 @@ UINT32 OsShellShowTickRespo(VOID)
     (VOID)memset_s((CHAR *)OsSchedDebugGet(), tickSize, 0, tickSize);
     for (cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) {
         SchedRunQue *rq = OsSchedRunQueByID(cpu);
-        sortLinkNum[cpu] = OsGetSortLinkNodeNum(&rq->taskSortLink) + OsGetSortLinkNodeNum(&rq->swtmrSortLink);
+        sortLinkNum[cpu] = OsGetSortLinkNodeNum(&rq->taskSortLink);
     }
     SCHEDULER_UNLOCK(intSave);
 
@@ -159,13 +158,6 @@ UINT32 OsShellShowTickRespo(VOID)
     (VOID)LOS_MemFree(m_aucSysMem1, schedDebug);
     return LOS_OK;
 }
-
-#else
-
-UINT32 OsShellShowTickRespo(VOID)
-{
-    return LOS_NOK;
-}
 #endif
 
 #ifdef LOSCFG_SCHED_DEBUG
@@ -175,6 +167,7 @@ UINT32 OsShellShowSchedParam(VOID)
     UINT64 averTimeSlice;
     UINT64 averSchedWait;
     UINT64 averPendTime;
+    UINT32 taskLinkNum[LOSCFG_KERNEL_CORE_NUM];
     UINT32 intSave;
     UINT32 size = g_taskMaxNum * sizeof(LosTaskCB);
     LosTaskCB *taskCBArray = LOS_MemAlloc(m_aucSysMem1, size);
@@ -184,7 +177,16 @@ UINT32 OsShellShowSchedParam(VOID)
 
     SCHEDULER_LOCK(intSave);
     (VOID)memcpy_s(taskCBArray, size, g_taskCBArray, size);
+    for (UINT16 cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) {
+        SchedRunQue *rq = OsSchedRunQueByID(cpu);
+        taskLinkNum[cpu] = OsGetSortLinkNodeNum(&rq->taskSortLink);
+    }
     SCHEDULER_UNLOCK(intSave);
+
+    for (UINT16 cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) {
+        PRINTK("cpu: %u Task SortMax: %u\n", cpu, taskLinkNum[cpu]);
+    }
+
     PRINTK("  Tid    AverRunTime(us)    SwitchCount  AverTimeSlice(us)    TimeSliceCount  AverReadyWait(us)  "
            "AverPendTime(us)  TaskName \n");
     for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
@@ -228,13 +230,6 @@ UINT32 OsShellShowSchedParam(VOID)
 
     return LOS_OK;
 }
-
-#else
-
-UINT32 OsShellShowSchedParam(VOID)
-{
-    return LOS_NOK;
-}
 #endif
 
 STATIC INLINE VOID TimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime)
@@ -259,28 +254,12 @@ STATIC INLINE VOID TimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime)
 #endif
 }
 
-STATIC INLINE UINT64 GetNextExpireTime(SchedRunQue *rq, UINT64 startTime, UINT32 tickPrecision)
-{
-    SortLinkAttribute *taskHeader = &rq->taskSortLink;
-    SortLinkAttribute *swtmrHeader = &rq->swtmrSortLink;
-
-    LOS_SpinLock(&taskHeader->spinLock);
-    UINT64 taskExpireTime = OsGetSortLinkNextExpireTime(taskHeader, startTime, tickPrecision);
-    LOS_SpinUnlock(&taskHeader->spinLock);
-
-    LOS_SpinLock(&swtmrHeader->spinLock);
-    UINT64 swtmrExpireTime = OsGetSortLinkNextExpireTime(swtmrHeader, startTime, tickPrecision);
-    LOS_SpinUnlock(&swtmrHeader->spinLock);
-
-    return (taskExpireTime < swtmrExpireTime) ? taskExpireTime : swtmrExpireTime;
-}
-
 STATIC INLINE VOID SchedSetNextExpireTime(UINT32 responseID, UINT64 taskEndTime, UINT32 oldResponseID)
 {
     SchedRunQue *rq = OsSchedRunQue();
     BOOL isTimeSlice = FALSE;
     UINT64 currTime = OsGetCurrSchedTimeCycle();
-    UINT64 nextExpireTime = GetNextExpireTime(rq, currTime, OS_TICK_RESPONSE_PRECISION);
+    UINT64 nextExpireTime = OsGetSortLinkNextExpireTime(&rq->taskSortLink, currTime, OS_TICK_RESPONSE_PRECISION);
 
     rq->schedFlag &= ~INT_PEND_TICK;
     if (rq->responseID == oldResponseID) {
@@ -496,7 +475,7 @@ VOID OsSchedTaskExit(LosTaskCB *taskCB)
     }
 
     if (taskCB->taskStatus & (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)) {
-        OsSchedDeTaskFromTimeList(&taskCB->sortList);
+        OsSchedDeTaskFromTimeList(taskCB);
         taskCB->taskStatus &= ~(OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME);
     }
 }
@@ -512,11 +491,10 @@ VOID OsSchedYield(VOID)
     OsSchedResched();
 }
 
-VOID OsSchedDelay(LosTaskCB *runTask, UINT32 tick)
+VOID OsSchedDelay(LosTaskCB *runTask, UINT64 waitTime)
 {
-    OsSchedTaskDeQueue(runTask);
     runTask->taskStatus |= OS_TASK_STATUS_DELAY;
-    runTask->waitTimes = tick;
+    runTask->waitTime = waitTime;
 
     OsSchedResched();
 }
@@ -530,7 +508,7 @@ UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched)
 
     if (ticks != LOS_WAIT_FOREVER) {
         runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME;
-        runTask->waitTimes = ticks;
+        runTask->waitTime = OS_SCHED_TICK_TO_CYCLE(ticks);
     }
 
     if (needSched == TRUE) {
@@ -550,7 +528,7 @@ VOID OsSchedTaskWake(LosTaskCB *resumedTask)
     resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING;
 
     if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) {
-        OsSchedDeTaskFromTimeList(&resumedTask->sortList);
+        OsSchedDeTaskFromTimeList(resumedTask);
         resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME;
     }
 
@@ -625,7 +603,7 @@ STATIC VOID SchedFreezeTask(LosTaskCB *taskCB)
     }
 
     responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
-    OsSchedDeTaskFromTimeList(&taskCB->sortList);
+    OsSchedDeTaskFromTimeList(taskCB);
     SET_SORTLIST_VALUE(&taskCB->sortList, responseTime);
     taskCB->taskStatus |= OS_TASK_FLAG_FREEZE;
     return;
@@ -634,7 +612,6 @@ STATIC VOID SchedFreezeTask(LosTaskCB *taskCB)
 STATIC VOID SchedUnfreezeTask(LosTaskCB *taskCB)
 {
     UINT64 currTime, responseTime;
-    UINT32 remainTick;
 
     if (!(taskCB->taskStatus & OS_TASK_FLAG_FREEZE)) {
         return;
@@ -644,8 +621,7 @@ STATIC VOID SchedUnfreezeTask(LosTaskCB *taskCB)
     currTime = OsGetCurrSchedTimeCycle();
     responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
     if (responseTime > currTime) {
-        remainTick = ((responseTime - currTime) + OS_CYCLE_PER_TICK - 1) / OS_CYCLE_PER_TICK;
-        OsSchedAddTask2TimeList(&taskCB->sortList, currTime, remainTick);
+        OsSchedAddTask2TimeList(taskCB, responseTime);
         return;
     }
 
@@ -687,97 +663,6 @@ BOOL OsSchedResume(LosTaskCB *taskCB)
     return needSched;
 }
 
-STATIC INLINE BOOL SchedScanSwtmrTimeList(SchedRunQue *rq)
-{
-    BOOL needSched = FALSE;
-    SortLinkAttribute* swtmrSortLink = &rq->swtmrSortLink;
-    LOS_DL_LIST *listObject = &swtmrSortLink->sortLink;
-
-    /*
-     * it needs to be carefully coped with, since the swtmr is in specific sortlink
-     * while other cores still has the chance to process it, like stop the timer.
-     */
-    LOS_SpinLock(&swtmrSortLink->spinLock);
-
-    if (LOS_ListEmpty(listObject)) {
-        LOS_SpinUnlock(&swtmrSortLink->spinLock);
-        return FALSE;
-    }
-    SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-
-    UINT64 currTime = OsGetCurrSchedTimeCycle();
-    while (sortList->responseTime <= currTime) {
-        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-        UINT64 startTime = GET_SORTLIST_VALUE(sortList);
-        OsDeleteNodeSortLink(swtmrSortLink, sortList);
-        LOS_SpinUnlock(&swtmrSortLink->spinLock);
-
-        OsSwtmrWake(rq, startTime, sortList);
-        needSched = TRUE;
-
-        LOS_SpinLock(&swtmrSortLink->spinLock);
-        if (LOS_ListEmpty(listObject)) {
-            break;
-        }
-
-        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
-    }
-
-    LOS_SpinUnlock(&swtmrSortLink->spinLock);
-    return needSched;
-}
-
-STATIC INLINE VOID SchedSwtmrResponseTimeReset(SchedRunQue *rq, UINT64 startTime)
-{
-    SortLinkAttribute* swtmrSortLink = &rq->swtmrSortLink;
-    LOS_DL_LIST *listHead = &swtmrSortLink->sortLink;
-    LOS_DL_LIST *listNext = listHead->pstNext;
-
-    LOS_SpinLock(&swtmrSortLink->spinLock);
-    while (listNext != listHead) {
-        SortLinkList *sortList = LOS_DL_LIST_ENTRY(listNext, SortLinkList, sortLinkNode);
-        OsDeleteNodeSortLink(swtmrSortLink, sortList);
-        LOS_SpinUnlock(&swtmrSortLink->spinLock);
-
-        OsSwtmrRestart(startTime, sortList);
-
-        LOS_SpinLock(&swtmrSortLink->spinLock);
-        listNext = listNext->pstNext;
-    }
-    LOS_SpinUnlock(&swtmrSortLink->spinLock);
-}
-
-STATIC INLINE BOOL SchedSwtmrRunQueFind(SortLinkAttribute *swtmrSortLink, SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
-{
-    LOS_DL_LIST *listObject = &swtmrSortLink->sortLink;
-    LOS_DL_LIST *list = listObject->pstNext;
-
-    LOS_SpinLock(&swtmrSortLink->spinLock);
-    while (list != listObject) {
-        SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
-        if (checkFunc((UINTPTR)listSorted, arg)) {
-            LOS_SpinUnlock(&swtmrSortLink->spinLock);
-            return TRUE;
-        }
-        list = list->pstNext;
-    }
-
-    LOS_SpinUnlock(&swtmrSortLink->spinLock);
-    return FALSE;
-}
-
-BOOL OsSchedSwtmrTimeListFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
-{
-    for (UINT16 cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
-        SchedRunQue *rq = OsSchedRunQueByID(cpuid);
-        SortLinkAttribute *swtmrSortLink = &rq->swtmrSortLink;
-        if (SchedSwtmrRunQueFind(swtmrSortLink, checkFunc, arg)) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
 STATIC INLINE VOID SchedWakePendTimeTask(UINT64 currTime, LosTaskCB *taskCB, BOOL *needSchedule)
 {
 #ifndef LOSCFG_SCHED_DEBUG
@@ -853,14 +738,9 @@ STATIC INLINE BOOL SchedScanTaskTimeList(SchedRunQue *rq)
 VOID OsSchedTick(VOID)
 {
     SchedRunQue *rq = OsSchedRunQue();
-    BOOL needSched = FALSE;
 
     if (rq->responseID == OS_INVALID_VALUE) {
-
-        needSched |= SchedScanSwtmrTimeList(rq);
-        needSched |= SchedScanTaskTimeList(rq);
-
-        if (needSched) {
+        if (SchedScanTaskTimeList(rq)) {
             LOS_MpSchedule(OS_MP_CPU_ALL);
             rq->schedFlag |= INT_PEND_RESCH;
         }
@@ -892,18 +772,10 @@ VOID OsSchedRunQueInit(VOID)
     for (UINT16 index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
         SchedRunQue *rq = OsSchedRunQueByID(index);
         OsSortLinkInit(&rq->taskSortLink);
-        OsSortLinkInit(&rq->swtmrSortLink);
         rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
     }
 }
 
-VOID OsSchedRunQueSwtmrInit(UINT32 swtmrTaskID, UINT32 swtmrQueue)
-{
-    SchedRunQue *rq = OsSchedRunQue();
-    rq->swtmrTaskID = swtmrTaskID;
-    rq->swtmrHandlerQueue = swtmrQueue;
-}
-
 VOID OsSchedRunQueIdleInit(UINT32 idleTaskID)
 {
     SchedRunQue *rq = OsSchedRunQue();
@@ -975,9 +847,7 @@ VOID OsSchedStart(VOID)
 
     SCHEDULER_LOCK(intSave);
 
-    if (cpuid == 0) {
     OsTickStart();
-    }
 
     SchedRunQue *rq = OsSchedRunQue();
     LosTaskCB *newTask = GetTopTask(rq);
@@ -995,7 +865,7 @@ VOID OsSchedStart(VOID)
 
     newTask->startTime = OsGetCurrSchedTimeCycle();
 
-    SchedSwtmrResponseTimeReset(rq, newTask->startTime);
+    OsSwtmrResponseTimeReset(newTask->startTime);
 
     /* System start schedule */
     OS_SCHEDULER_SET(cpuid);
@@ -1078,7 +948,7 @@ STATIC VOID SchedTaskSwitch(LosTaskCB *runTask, LosTaskCB *newTask)
         TimeSliceUpdate(runTask, newTask->startTime);
 
         if (runTask->taskStatus & (OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY)) {
-            OsSchedAddTask2TimeList(&runTask->sortList, runTask->startTime, runTask->waitTimes);
+            OsSchedAddTask2TimeList(runTask, runTask->startTime + runTask->waitTime);
         }
     }
 

kernel/base/sched/sched_sq/los_sortlink.c

@@ -82,21 +82,30 @@ VOID OsAdd2SortLink(SortLinkAttribute *head, SortLinkList *node, UINT64 response
     node->cpuid = idleCpu;
 #endif
     LOS_SpinUnlock(&head->spinLock);
+}
 
-#ifdef LOSCFG_KERNEL_SMP
-    if (idleCpu != ArchCurrCpuid()) {
-        LOS_MpSchedule(CPUID_TO_AFFI_MASK(idleCpu));
+VOID OsDeleteFromSortLink(SortLinkAttribute *head, SortLinkList *node)
+{
+    LOS_SpinLock(&head->spinLock);
+    if (node->responseTime != OS_SORT_LINK_INVALID_TIME) {
+        OsDeleteNodeSortLink(head, node);
     }
-#endif
+    LOS_SpinUnlock(&head->spinLock);
 }
 
-VOID OsDeleteFromSortLink(SortLinkAttribute *head, SortLinkList *node)
+UINT32 OsSortLinkAdjustNodeResponseTime(SortLinkAttribute *head, SortLinkList *node, UINT64 responseTime)
 {
+    UINT32 ret = LOS_NOK;
+
     LOS_SpinLock(&head->spinLock);
     if (node->responseTime != OS_SORT_LINK_INVALID_TIME) {
         OsDeleteNodeSortLink(head, node);
+        SET_SORTLIST_VALUE(node, responseTime);
+        AddNode2SortLink(head, node);
+        ret = LOS_OK;
     }
     LOS_SpinUnlock(&head->spinLock);
+    return ret;
 }
 
 UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList)

kernel/extended/cpup/los_cpup.c

@@ -254,7 +254,7 @@ VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
     OsCpupBase *newTaskCpup = (OsCpupBase *)&(OS_TCB_FROM_TID(newTaskID)->taskCpup);
     OsCpupBase *processCpup = OS_PCB_FROM_PID(runTask->processID)->processCpup;
     UINT64 cpuCycle, cycleIncrement;
-    UINT16 cpuID = ArchCurrCpuid();
+    UINT16 cpuid = ArchCurrCpuid();
 
     if (cpupInitFlg == 0) {
         return;
@@ -264,8 +264,8 @@ VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
     if (runTaskCpup->startTime != 0) {
         cycleIncrement = cpuCycle - runTaskCpup->startTime;
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-        cycleIncrement -= timeInIrqSwitch[cpuID];
-        timeInIrqSwitch[cpuID] = 0;
+        cycleIncrement -= timeInIrqSwitch[cpuid];
+        timeInIrqSwitch[cpuid] = 0;
 #endif
         runTaskCpup->allTime += cycleIncrement;
         if (processCpup != NULL) {
@@ -275,7 +275,7 @@ VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
     }
 
     newTaskCpup->startTime = cpuCycle;
-    runningTasks[cpuID] = newTaskID;
+    runningTasks[cpuid] = newTaskID;
 }
 
 LITE_OS_SEC_TEXT_MINOR STATIC VOID OsCpupGetPos(UINT16 mode, UINT16 *curPosPointer, UINT16 *prePosPointer)
@@ -524,17 +524,17 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode,
 }
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart(UINT16 cpuId)
+LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart(UINT16 cpuid)
 {
     UINT32 high;
     UINT32 low;
 
     LOS_GetCpuCycle(&high, &low);
-    cpupIntTimeStart[cpuId] = ((UINT64)high << HIGH_BITS) + low;
+    cpupIntTimeStart[cpuid] = ((UINT64)high << HIGH_BITS) + low;
     return;
 }
 
-LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT16 cpuId, UINT32 intNum)
+LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT16 cpuid, UINT32 intNum)
 {
     UINT32 high;
     UINT32 low;
@@ -543,11 +543,11 @@ LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT16 cpuId, UINT32 intNum)
 
     LOS_GetCpuCycle(&high, &low);
     intTimeEnd = ((UINT64)high << HIGH_BITS) + low;
-    OsIrqCpupCB *irqCb = &g_irqCpup[(intNum * LOSCFG_KERNEL_CORE_NUM) + cpuId];
+    OsIrqCpupCB *irqCb = &g_irqCpup[(intNum * LOSCFG_KERNEL_CORE_NUM) + cpuid];
     irqCb->id = intNum;
     irqCb->status = OS_CPUP_USED;
-    usedTime = intTimeEnd - cpupIntTimeStart[cpuId];
-    timeInIrqSwitch[cpuId] += usedTime;
+    usedTime = intTimeEnd - cpupIntTimeStart[cpuid];
+    timeInIrqSwitch[cpuid] += usedTime;
     irqCb->cpup.allTime += usedTime;
     if (irqCb->count <= 100) { /* Take 100 samples */
         irqCb->allTime += usedTime;

kernel/extended/trace/los_trace.c

@@ -101,7 +101,7 @@ STATIC VOID OsTraceSetFrame(TraceEventFrame *frame, UINT32 eventType, UINTPTR id
     frame->eventType = eventType;
 
 #ifdef LOSCFG_TRACE_FRAME_CORE_MSG
-    frame->core.cpuId      = ArchCurrCpuid();
+    frame->core.cpuid      = ArchCurrCpuid();
     frame->core.hwiActive  = OS_INT_ACTIVE ? TRUE : FALSE;
     frame->core.taskLockCnt = MIN(OsSchedLockCountGet(), 0xF); /* taskLockCnt is 4 bits, max value = 0xF */
     frame->core.paramCount = paramCount;

kernel/extended/trace/trace_offline.c

@@ -157,7 +157,7 @@ STATIC VOID OsTraceInfoEventTitle(VOID)
 
     PRINTK("Index   Time(cycles)      EventType      CurPid   CurTask   Identity      ");
 #ifdef LOSCFG_TRACE_FRAME_CORE_MSG
-    PRINTK("cpuId    hwiActive    taskLockCnt    ");
+    PRINTK("cpuid    hwiActive    taskLockCnt    ");
 #endif
 #ifdef LOSCFG_TRACE_FRAME_EVENT_COUNT
     PRINTK("eventCount    ");
@@ -192,7 +192,7 @@ STATIC VOID OsTraceInfoEventData(VOID)
          */
         taskLockCnt -= 1;
 #endif
-        PRINTK("%-11u %-11u %-11u", frame->core.cpuId, frame->core.hwiActive, taskLockCnt);
+        PRINTK("%-11u %-11u %-11u", frame->core.cpuid, frame->core.hwiActive, taskLockCnt);
 #endif
 #ifdef LOSCFG_TRACE_FRAME_EVENT_COUNT
         PRINTK("%-11u", frame->eventCount);

kernel/include/los_trace.h

@@ -245,7 +245,7 @@ typedef struct {
     UINTPTR identity;                                /**< subject of the event description */
 #ifdef LOSCFG_TRACE_FRAME_CORE_MSG
     struct CoreStatus {
-        UINT32 cpuId      : 8,                       /**< cpuid */
+        UINT32 cpuid      : 8,                       /**< cpuid */
                hwiActive  : 4,                       /**< whether is in hwi response */
                taskLockCnt : 4,                      /**< task lock count */
                paramCount : 4,                       /**< event frame params' number */

testsuites/kernel/include/osTest.h

@@ -343,7 +343,7 @@ extern void TestSystemInit(void);
 extern void TEST_DT_COMMON(void);
 extern VOID dprintf(const char *fmt, ...);
 
-extern UINT32 OsSwtmrTaskIdByCpuId(UINT16 cpuId);
+extern UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid);
 
 #define BIG_FD 512
 typedef struct testrunParam {

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_081.c

@@ -49,7 +49,7 @@ static UINT32 Testcase(void)
     ret = LOS_TaskSuspend(gTestIdleTaskID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK, ret);
 
-    gTestSwtmrTaskID = OsSwtmrTaskIdByCpuId(cpuid);
+    gTestSwtmrTaskID = OsSwtmrTaskIDGetByCpuid(cpuid);
 
     ret = LOS_TaskSuspend(gTestSwtmrTaskID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK, ret);

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_114.c

@@ -49,7 +49,7 @@ static UINT32 Testcase(void)
     ret = LOS_TaskDelete(gTestIdleTaskID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK, ret);
 
-    gTestSwtmrTaskID = OsSwtmrTaskIdByCpuId(cpuid);
+    gTestSwtmrTaskID = OsSwtmrTaskIDGetByCpuid(cpuid);
 
     ret = LOS_TaskDelete(gTestSwtmrTaskID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK, ret);

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_115.c

@@ -44,7 +44,7 @@ static UINT32 Testcase(void)
     UINT32 gTestSwtmrTaskID;
     UINT32 cpuid = (ArchCurrCpuid() + 1) % (LOSCFG_KERNEL_CORE_NUM);
 
-    gTestSwtmrTaskID = OsSwtmrTaskIdByCpuId(cpuid);
+    gTestSwtmrTaskID = OsSwtmrTaskIDGetByCpuid(cpuid);
 
     ret = LOS_TaskDelete(gTestSwtmrTaskID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK, ret);

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_126.c

@@ -54,7 +54,7 @@ static void HwiF01(void)
 
     LOS_AtomicInc(&g_testCount);
 
-    gTestSwtmrTaskID = OsSwtmrTaskIdByCpuId(cpuid);
+    gTestSwtmrTaskID = OsSwtmrTaskIDGetByCpuid(cpuid);
 
     ret = LOS_TaskDelete(gTestSwtmrTaskID);
     ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_TSK_YIELD_IN_INT, ret);

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_127.c

@@ -49,7 +49,7 @@ static void HwiF01(void)
     ret = LOS_TaskDelete(gTestIdleTaskID);
     ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_TSK_YIELD_IN_INT, ret);
 
-    gTestSwtmrTaskID = OsSwtmrTaskIdByCpuId(cpuid);
+    gTestSwtmrTaskID = OsSwtmrTaskIDGetByCpuid(cpuid);
 
     ret = LOS_TaskDelete(gTestSwtmrTaskID);
     ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_TSK_YIELD_IN_INT, ret);