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

背景：原调度机制与软件定时器实现混合，调度时间链表存在两个链表，任务切换时需要遍历两个链表才可以获取到最终的tick响应时间。软件定时作为一个独立的功能，不应该和调度强耦合，而且软件定时器作为一个任务，某个软件定时器的响应时间应该是软件定时器任务的响应时间，不应该直接做为tick中断的响应时间。方案描述： 1.将软件定时器从调度分离，作为一个独立的机制，从调度角度看其就是一个任务 2.软件定时器从调度分离之后，其timelist遍历从tick中断移动至软件定时器任务中 3.优化软件定时器的均衡调度优势： 1.将软件定时器与调度完全分离，使得调度功能单一化，便于后续其它调度算法的引入 2.优化tick中断，减小tick中断耗时 3.优化通过写队列唤醒软件定时器任务去执行软件定时器钩子为插队列，减少软件定时器机制本身的耗时，提升软件定时器的实时性 4.优化软件定时器均衡调度，使得软件定时器均匀分布于多核，提升软件定时器的实时性 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I07c01f134e69c1d9b7061ddf5a231df1ee99b68e
2022-03-16 20:28:30 +08:00
parent e4cad073a9
commit 6d8cef40c8
21 changed files with 523 additions and 416 deletions
--- a/kernel/base/core/los_swtmr.c
+++ b/kernel/base/core/los_swtmr.c
@@ -43,6 +43,9 @@
 #error "swtmr maxnum cannot be zero"
 #endif /* LOSCFG_BASE_CORE_SWTMR_LIMIT <= 0 */

+STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr);
+STATIC INLINE UINT64 SwtmrToStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid);
+
 LITE_OS_SEC_BSS SWTMR_CTRL_S    *g_swtmrCBArray = NULL;     /* First address in Timer memory space */
 LITE_OS_SEC_BSS UINT8           *g_swtmrHandlerPool = NULL; /* Pool of Swtmr Handler */
 LITE_OS_SEC_BSS LOS_DL_LIST     g_swtmrFreeList;            /* Free list of Software Timer */
@@ -52,6 +55,14 @@ LITE_OS_SEC_BSS  SPIN_LOCK_INIT(g_swtmrSpin);
 #define SWTMR_LOCK(state)       LOS_SpinLockSave(&g_swtmrSpin, &(state))
 #define SWTMR_UNLOCK(state)     LOS_SpinUnlockRestore(&g_swtmrSpin, (state))

+typedef struct {
+    SortLinkAttribute swtmrSortLink;
+    LosTaskCB         *swtmrTask;           /* software timer task id */
+    LOS_DL_LIST       swtmrHandlerQueue;     /* software timer timeout queue id */
+} SwtmrRunQue;
+
+STATIC SwtmrRunQue g_swtmrRunQue[LOSCFG_KERNEL_CORE_NUM];
+
 #ifdef LOSCFG_SWTMR_DEBUG
 #define OS_SWTMR_PERIOD_TO_CYCLE(period) (((UINT64)(period) * OS_NS_PER_TICK) / OS_NS_PER_CYCLE)
 STATIC SwtmrDebugData *g_swtmrDebugData = NULL;
@@ -100,40 +111,34 @@ STATIC VOID SwtmrDebugDataInit(VOID)
 #endif
 }

-STATIC INLINE VOID SwtmrDebugDataUpdate(SWTMR_CTRL_S *swtmr, UINT32 ticks)
+STATIC INLINE VOID SwtmrDebugDataUpdate(SWTMR_CTRL_S *swtmr, UINT32 ticks, UINT32 times)
 {
 #ifdef LOSCFG_SWTMR_DEBUG
    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
-    data->startTime = swtmr->startTime;
    if (data->period != ticks) {
-        data->waitCount = 0;
-        data->runCount = 0;
-        data->waitTime = 0;
-        data->waitTimeMax = 0;
-        data->runTime = 0;
-        data->runTimeMax = 0;
-        data->readyTime = 0;
-        data->readyTimeMax = 0;
+        (VOID)memset_s(&data->base, sizeof(SwtmrDebugBase), 0, sizeof(SwtmrDebugBase));
        data->period = ticks;
    }
+    data->base.startTime = swtmr->startTime;
+    data->base.times += times;
 #endif
 }

-STATIC INLINE VOID SwtmrDebugDataStart(SWTMR_CTRL_S *swtmr, UINT16 cpuId)
+STATIC INLINE VOID SwtmrDebugDataStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid)
 {
 #ifdef LOSCFG_SWTMR_DEBUG
    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
    data->swtmrUsed = TRUE;
    data->handler = swtmr->pfnHandler;
-    data->cpuId = cpuId;
+    data->cpuid = cpuid;
 #endif
 }

-STATIC INLINE VOID SwtmrDebugWaitTimeCalculate(UINT32 timerId, SwtmrHandlerItemPtr swtmrHandler)
+STATIC INLINE VOID SwtmrDebugWaitTimeCalculate(UINT32 swtmrID, SwtmrHandlerItemPtr swtmrHandler)
 {
 #ifdef LOSCFG_SWTMR_DEBUG
-    SwtmrDebugData *data = &g_swtmrDebugData[timerId];
-    swtmrHandler->swtmrId = timerId;
+    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrID].base;
+    swtmrHandler->swtmrID = swtmrID;
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    UINT64 waitTime = currTime - data->startTime;
    data->waitTime += waitTime;
@@ -141,15 +146,14 @@ STATIC INLINE VOID SwtmrDebugWaitTimeCalculate(UINT32 timerId, SwtmrHandlerItemP
        data->waitTimeMax = waitTime;
    }
    data->readyStartTime = currTime;
-    LOS_ASSERT(waitTime >= OS_SWTMR_PERIOD_TO_CYCLE(data->period));
    data->waitCount++;
 #endif
 }

-STATIC INLINE VOID SwtmrDebugDataClear(UINT32 timerId)
+STATIC INLINE VOID SwtmrDebugDataClear(UINT32 swtmrID)
 {
 #ifdef LOSCFG_SWTMR_DEBUG
-    (VOID)memset_s(&g_swtmrDebugData[timerId], sizeof(SwtmrDebugData), 0, sizeof(SwtmrDebugData));
+    (VOID)memset_s(&g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData), 0, sizeof(SwtmrDebugData));
 #endif
 }

@@ -157,7 +161,7 @@ STATIC INLINE VOID SwtmrHandler(SwtmrHandlerItemPtr swtmrHandle)
 {
 #ifdef LOSCFG_SWTMR_DEBUG
    UINT32 intSave;
-    SwtmrDebugData *data = &g_swtmrDebugData[swtmrHandle->swtmrId];
+    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrHandle->swtmrID].base;
    UINT64 startTime = OsGetCurrSchedTimeCycle();
 #endif
    swtmrHandle->handler(swtmrHandle->arg);
@@ -178,16 +182,102 @@ STATIC INLINE VOID SwtmrHandler(SwtmrHandlerItemPtr swtmrHandle)
 #endif
 }

+STATIC INLINE VOID SwtmrWake(SwtmrRunQue *srq, UINT64 startTime, SortLinkList *sortList)
+{
+    UINT32 intSave;
+    SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
+    SwtmrHandlerItemPtr swtmrHandler = (SwtmrHandlerItemPtr)LOS_MemboxAlloc(g_swtmrHandlerPool);
+    LOS_ASSERT(swtmrHandler != NULL);
+
+    OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
+
+    SWTMR_LOCK(intSave);
+    swtmrHandler->handler = swtmr->pfnHandler;
+    swtmrHandler->arg = swtmr->uwArg;
+    LOS_ListTailInsert(&srq->swtmrHandlerQueue, &swtmrHandler->node);
+    SwtmrDebugWaitTimeCalculate(swtmr->usTimerID, swtmrHandler);
+
+    if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) {
+        SwtmrDelete(swtmr);
+
+        if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
+            swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT;
+        } else {
+            swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
+        }
+    } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
+        swtmr->ucState = OS_SWTMR_STATUS_CREATED;
+    } else {
+        swtmr->uwOverrun++;
+        swtmr->startTime = startTime;
+        (VOID)SwtmrToStart(swtmr, ArchCurrCpuid());
+    }
+
+    SWTMR_UNLOCK(intSave);
+}
+
+STATIC INLINE VOID ScanSwtmrTimeList(SwtmrRunQue *srq)
+{
+    UINT32 intSave;
+    SortLinkAttribute *swtmrSortLink = &srq->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_SpinLockSave(&swtmrSortLink->spinLock, &intSave);
+
+    if (LOS_ListEmpty(listObject)) {
+        LOS_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
+        return;
+    }
+    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_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
+
+        SwtmrWake(srq, startTime, sortList);
+
+        LOS_SpinLockSave(&swtmrSortLink->spinLock, &intSave);
+        if (LOS_ListEmpty(listObject)) {
+            break;
+        }
+
+        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
+    }
+
+    LOS_SpinUnlockRestore(&swtmrSortLink->spinLock, intSave);
+    return;
+}
+
 STATIC VOID SwtmrTask(VOID)
 {
-    SwtmrHandlerItemPtr swtmrHandlePtr = NULL;
    SwtmrHandlerItem swtmrHandle;
-    UINT32 ret, swtmrHandlerQueue;
+    UINT32 intSave;
+    UINT64 waitTime;

-    swtmrHandlerQueue = OsSchedSwtmrHandlerQueueGet();
+    SwtmrRunQue *srq = &g_swtmrRunQue[ArchCurrCpuid()];
+    LOS_DL_LIST *head = &srq->swtmrHandlerQueue;
    for (;;) {
-        ret = LOS_QueueRead(swtmrHandlerQueue, &swtmrHandlePtr, sizeof(CHAR *), LOS_WAIT_FOREVER);
-        if ((ret == LOS_OK) && (swtmrHandlePtr != NULL)) {
+        waitTime = OsSortLinkGetNextExpireTime(OsGetCurrSchedTimeCycle(), &srq->swtmrSortLink);
+        if (waitTime != 0) {
+            SCHEDULER_LOCK(intSave);
+            OsSchedDelay(srq->swtmrTask, waitTime);
+            OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, srq->swtmrTask);
+            SCHEDULER_UNLOCK(intSave);
+        }
+
+        ScanSwtmrTimeList(srq);
+
+        while (!LOS_ListEmpty(head)) {
+            SwtmrHandlerItemPtr swtmrHandlePtr = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(head), SwtmrHandlerItem, node);
+            LOS_ListDelete(&swtmrHandlePtr->node);
+
            (VOID)memcpy_s(&swtmrHandle, sizeof(SwtmrHandlerItem), swtmrHandlePtr, sizeof(SwtmrHandlerItem));
            (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandlePtr);
            SwtmrHandler(&swtmrHandle);
@@ -217,6 +307,11 @@ STATIC UINT32 SwtmrTaskCreate(UINT16 cpuid, UINT32 *swtmrTaskID)
    return ret;
 }

+UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid)
+{
+    return g_swtmrRunQue[cpuid].swtmrTask->taskID;
+}
+
 BOOL OsIsSwtmrTask(const LosTaskCB *taskCB)
 {
    if (taskCB->taskEntry == (TSK_ENTRY_FUNC)SwtmrTask) {
@@ -242,7 +337,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
    SWTMR_CTRL_S *swtmr = NULL;
    UINT32 swtmrHandlePoolSize;
    UINT32 cpuid = ArchCurrCpuid();
-    UINT32 swtmrTaskID, swtmrHandlerQueue;
+    UINT32 swtmrTaskID;

    if (cpuid == 0) {
        size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
@@ -270,17 +365,20 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)

        ret = LOS_MemboxInit(g_swtmrHandlerPool, swtmrHandlePoolSize, sizeof(SwtmrHandlerItem));
        if (ret != LOS_OK) {
+            (VOID)LOS_MemFree(m_aucSysMem1, g_swtmrHandlerPool);
            ret = LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
            goto ERROR;
        }

-        SwtmrDebugDataInit();
-    }
+        for (UINT16 index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
+            SwtmrRunQue *srq = &g_swtmrRunQue[index];
+            /* The linked list of all cores must be initialized at core 0 startup for load balancing */
+            OsSortLinkInit(&srq->swtmrSortLink);
+            LOS_ListInit(&srq->swtmrHandlerQueue);
+            srq->swtmrTask = NULL;
+        }

-    ret = LOS_QueueCreate(NULL, OS_SWTMR_HANDLE_QUEUE_SIZE, &swtmrHandlerQueue, 0, sizeof(CHAR *));
-    if (ret != LOS_OK) {
-        ret = LOS_ERRNO_SWTMR_QUEUE_CREATE_FAILED;
-        goto ERROR;
+        SwtmrDebugDataInit();
    }

    ret = SwtmrTaskCreate(cpuid, &swtmrTaskID);
@@ -289,7 +387,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
        goto ERROR;
    }

-    OsSchedRunQueSwtmrInit(swtmrTaskID, swtmrHandlerQueue);
+    SwtmrRunQue *srq = &g_swtmrRunQue[cpuid];
+    srq->swtmrTask = OsGetTaskCB(swtmrTaskID);
    return LOS_OK;

 ERROR:
@@ -297,13 +396,75 @@ ERROR:
    return ret;
 }

-/*
- * Description: Start Software Timer
- * Input      : swtmr --- Need to start software timer
- */
-LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr)
+#ifdef LOSCFG_KERNEL_SMP
+STATIC INLINE VOID FindIdleSwtmrRunQue(UINT16 *idleCpuid)
+{
+    SwtmrRunQue *idleRq = &g_swtmrRunQue[0];
+    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->swtmrSortLink);
+    UINT16 cpuid = 1;
+    do {
+        SwtmrRunQue *srq = &g_swtmrRunQue[cpuid];
+        UINT32 temp = OsGetSortLinkNodeNum(&srq->swtmrSortLink);
+        if (nodeNum > temp) {
+            *idleCpuid = cpuid;
+            nodeNum = temp;
+        }
+        cpuid++;
+    } while (cpuid < LOSCFG_KERNEL_CORE_NUM);
+}
+#endif
+
+STATIC INLINE VOID AddSwtmr2TimeList(SortLinkList *node, UINT64 responseTime, UINT16 cpuid)
+{
+    SwtmrRunQue *srq = &g_swtmrRunQue[cpuid];
+    OsAdd2SortLink(&srq->swtmrSortLink, node, responseTime, cpuid);
+}
+
+STATIC INLINE VOID DeSwtmrFromTimeList(SortLinkList *node)
+{
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16 cpuid = OsGetSortLinkNodeCpuid(node);
+#else
+    UINT16 cpuid = 0;
+#endif
+    SwtmrRunQue *srq = &g_swtmrRunQue[cpuid];
+    OsDeleteFromSortLink(&srq->swtmrSortLink, node);
+    return;
+}
+
+STATIC VOID SwtmrAdjustCheck(UINT16 cpuid, UINT64 responseTime)
+{
+    UINT32 ret;
+    UINT32 intSave;
+    SwtmrRunQue *srq = &g_swtmrRunQue[cpuid];
+    SCHEDULER_LOCK(intSave);
+    if ((srq->swtmrTask == NULL) || !OsTaskIsBlocked(srq->swtmrTask)) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    if (responseTime >= GET_SORTLIST_VALUE(&srq->swtmrTask->sortList)) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    ret = OsSchedAdjustTaskFromTimeList(srq->swtmrTask, responseTime);
+    SCHEDULER_UNLOCK(intSave);
+    if (ret != LOS_OK) {
+        return;
+    }
+
+    if (cpuid == ArchCurrCpuid()) {
+        OsSchedUpdateExpireTime();
+    } else {
+        LOS_MpSchedule(CPUID_TO_AFFI_MASK(cpuid));
+    }
+}
+
+STATIC UINT64 SwtmrToStart(SWTMR_CTRL_S *swtmr, UINT16 cpuid)
 {
    UINT32 ticks;
+    UINT32 times = 0;

    if ((swtmr->uwOverrun == 0) && ((swtmr->ucMode == LOS_SWTMR_MODE_ONCE) ||
        (swtmr->ucMode == LOS_SWTMR_MODE_OPP) ||
@@ -314,17 +475,45 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr)
    }
    swtmr->ucState = OS_SWTMR_STATUS_TICKING;

-    OsSchedAddSwtmr2TimeList(&swtmr->stSortList, swtmr->startTime, ticks);
-    SwtmrDebugDataUpdate(swtmr, ticks);
-    OsSchedUpdateExpireTime();
-    return;
+    UINT64 period = (UINT64)ticks * OS_CYCLE_PER_TICK;
+    UINT64 responseTime = swtmr->startTime + period;
+    UINT64 currTime = OsGetCurrSchedTimeCycle();
+    if (responseTime < currTime) {
+        times = (UINT32)((currTime - swtmr->startTime) / period);
+        swtmr->startTime += times * period;
+        responseTime = swtmr->startTime + period;
+        PRINT_WARN("Swtmr already timeout! SwtmrID: %u\n", swtmr->usTimerID);
+    }
+
+    AddSwtmr2TimeList(&swtmr->stSortList, responseTime, cpuid);
+    SwtmrDebugDataUpdate(swtmr, ticks, times);
+    return responseTime;
+}
+
+/*
+ * Description: Start Software Timer
+ * Input      : swtmr --- Need to start software timer
+ */
+STATIC INLINE VOID SwtmrStart(SWTMR_CTRL_S *swtmr)
+{
+    UINT64 responseTime;
+    UINT16 idleCpu = 0;
+#ifdef LOSCFG_KERNEL_SMP
+    FindIdleSwtmrRunQue(&idleCpu);
+#endif
+    swtmr->startTime = OsGetCurrSchedTimeCycle();
+    responseTime = SwtmrToStart(swtmr, idleCpu);
+
+    SwtmrDebugDataStart(swtmr, idleCpu);
+
+    SwtmrAdjustCheck(idleCpu, responseTime);
 }

 /*
 * Description: Delete Software Timer
 * Input      : swtmr --- Need to delete software timer, When using, Ensure that it can't be NULL.
 */
-STATIC INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr)
+STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr)
 {
    /* insert to free list */
    LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
@@ -334,59 +523,74 @@ STATIC INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr)
    SwtmrDebugDataClear(swtmr->usTimerID);
 }

-VOID OsSwtmrWake(SchedRunQue *rq, UINT64 startTime, SortLinkList *sortList)
-{
-    SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
-
-    OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
-    LOS_SpinLock(&g_swtmrSpin);
-    SwtmrHandlerItemPtr swtmrHandler = (SwtmrHandlerItemPtr)LOS_MemboxAlloc(g_swtmrHandlerPool);
-    if (swtmrHandler != NULL) {
-        swtmrHandler->handler = swtmr->pfnHandler;
-        swtmrHandler->arg = swtmr->uwArg;
-        SwtmrDebugWaitTimeCalculate(swtmr->usTimerID, swtmrHandler);
-
-        if (LOS_QueueWrite(rq->swtmrHandlerQueue, swtmrHandler, sizeof(CHAR *), LOS_NO_WAIT)) {
-            (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandler);
-        }
-    }
-
-    if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) {
-        OsSwtmrDelete(swtmr);
-
-        if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
-            swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT;
-        } else {
-            swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
-        }
-    } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
-        swtmr->ucState = OS_SWTMR_STATUS_CREATED;
-    } else {
-        swtmr->uwOverrun++;
-        swtmr->startTime = startTime;
-        OsSwtmrStart(swtmr);
-    }
-
-    LOS_SpinUnlock(&g_swtmrSpin);
-}
-
-VOID OsSwtmrRestart(UINT64 startTime, SortLinkList *sortList)
+STATIC INLINE VOID SwtmrRestart(UINT64 startTime, SortLinkList *sortList, UINT16 cpuid)
 {
    UINT32 intSave;

    SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
    SWTMR_LOCK(intSave);
    swtmr->startTime = startTime;
-    OsSwtmrStart(swtmr);
+    (VOID)SwtmrToStart(swtmr, cpuid);
    SWTMR_UNLOCK(intSave);
 }

+VOID OsSwtmrResponseTimeReset(UINT64 startTime)
+{
+    UINT16 cpuid = ArchCurrCpuid();
+    SortLinkAttribute *swtmrSortLink = &g_swtmrRunQue[cpuid].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);
+
+        SwtmrRestart(startTime, sortList, cpuid);
+
+        LOS_SpinLock(&swtmrSortLink->spinLock);
+        listNext = listNext->pstNext;
+    }
+    LOS_SpinUnlock(&swtmrSortLink->spinLock);
+}
+
+STATIC INLINE BOOL SwtmrRunQueFind(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;
+}
+
+STATIC BOOL SwtmrTimeListFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
+{
+    for (UINT16 cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
+        SortLinkAttribute *swtmrSortLink = &g_swtmrRunQue[ArchCurrCpuid()].swtmrSortLink;
+        if (SwtmrRunQueFind(swtmrSortLink, checkFunc, arg)) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
 BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
 {
    UINT32 intSave;

    SWTMR_LOCK(intSave);
-    BOOL find = OsSchedSwtmrTimeListFind(checkFunc, arg);
+    BOOL find = SwtmrTimeListFind(checkFunc, arg);
    SWTMR_UNLOCK(intSave);
    return find;
 }
@@ -398,7 +602,8 @@ BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
 LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
 {
    UINT64 currTime = OsGetCurrSchedTimeCycle();
-    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &OsSchedRunQue()->swtmrSortLink) / OS_CYCLE_PER_TICK);
+    SwtmrRunQue *srq = &g_swtmrRunQue[ArchCurrCpuid()];
+    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &srq->swtmrSortLink) / OS_CYCLE_PER_TICK);
    if (time > OS_INVALID_VALUE) {
        time = OS_INVALID_VALUE;
    }
@@ -409,14 +614,12 @@ LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
 * Description: Stop of Software Timer interface
 * Input      : swtmr --- the software timer control handler
 */
-LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
+STATIC VOID SwtmrStop(SWTMR_CTRL_S *swtmr)
 {
-    OsSchedDeSwtmrFromTimeList(&swtmr->stSortList);
-
    swtmr->ucState = OS_SWTMR_STATUS_CREATED;
    swtmr->uwOverrun = 0;

-    OsSchedUpdateExpireTime();
+    DeSwtmrFromTimeList(&swtmr->stSortList);
 }

 /*
@@ -514,12 +717,10 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrID)
         * then start the swtmr again.
         */
        case OS_SWTMR_STATUS_TICKING:
-            OsSwtmrStop(swtmr);
+            SwtmrStop(swtmr);
            /* fall-through */
        case OS_SWTMR_STATUS_CREATED:
-            swtmr->startTime = OsGetCurrSchedTimeCycle();
-            SwtmrDebugDataStart(swtmr, ArchCurrCpuid());
-            OsSwtmrStart(swtmr);
+            SwtmrStart(swtmr);
            break;
        default:
            ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
@@ -559,7 +760,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrID)
            ret = LOS_ERRNO_SWTMR_NOT_STARTED;
            break;
        case OS_SWTMR_STATUS_TICKING:
-            OsSwtmrStop(swtmr);
+            SwtmrStop(swtmr);
            break;
        default:
            ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
@@ -637,10 +838,10 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT16 swtmrID)
            ret = LOS_ERRNO_SWTMR_NOT_CREATED;
            break;
        case OS_SWTMR_STATUS_TICKING:
-            OsSwtmrStop(swtmr);
+            SwtmrStop(swtmr);
            /* fall-through */
        case OS_SWTMR_STATUS_CREATED:
-            OsSwtmrDelete(swtmr);
+            SwtmrDelete(swtmr);
            break;
        default:
            ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
--- a/kernel/base/core/los_task.c
+++ b/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);