!247 fix: tick 动态化计算优化，减小中断执行时间对系统总体时间的影响，保证软件定时器的响应精度。

Merge pull request !247 from zhushengle/tick_sched

components/power/los_pm.c

@@ -107,7 +107,7 @@ STATIC VOID OsPmTickTimerStop(LosPmCB *pm)
     sleepCycle = OS_SYS_NS_TO_CYCLE(sleepCycle, tickTimer->freq);
 
     /* The main CPU reduces the frequency */
-    pm->enterSleepTime = OsGetCurrSchedTimeCycle();
+    pm->enterSleepTime = OsGetCurrSysTimeCycle();
     tickTimer->tickLock();
     tickTimer->timerStart(sleepCycle);
     return;

kernel/include/los_config.h

@@ -65,6 +65,22 @@ extern "C" {
 #define LOSCFG_BASE_CORE_TICK_PER_SECOND                    (100UL)
 #endif
 
+/**
+ * @ingroup los_config
+ * Minimum response error accuracy of tick interrupts, number of ticks in one second.
+ */
+#ifndef LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI
+#define LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI               (1000UL) /* 1ms */
+#endif
+
+#if (LOSCFG_BASE_CORE_TICK_PER_SECOND > LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI)
+    #error "LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI must be greater than LOSCFG_BASE_CORE_TICK_PER_SECOND"
+#endif
+
+#if (LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI > 1000UL)
+    #error "LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI must be less than or equal to 1000"
+#endif
+
 #if defined(LOSCFG_BASE_CORE_TICK_PER_SECOND) && \
     ((LOSCFG_BASE_CORE_TICK_PER_SECOND < 1UL) || (LOSCFG_BASE_CORE_TICK_PER_SECOND > 1000000000UL))
     #error "LOSCFG_BASE_CORE_TICK_PER_SECOND SHOULD big than 0, and less than 1000000000UL"

kernel/include/los_sched.h

@@ -42,14 +42,18 @@ extern "C" {
 #endif /* __cplusplus */
 #endif /* __cplusplus */
 
+#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)
 
 extern UINT32 g_taskScheduled;
 typedef BOOL (*SchedScan)(VOID);
 
+extern UINT64 g_sysSchedStartTime;
+
 VOID OsSchedUpdateSchedTimeBase(VOID);
 
-UINT64 OsGetCurrSchedTimeCycle(VOID);
+UINT64 OsGetCurrSysTimeCycle(VOID);
 
 VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask);
 
@@ -87,6 +91,15 @@ UINT32 OsSchedRealSleepTimeSet(VOID (*func)(UINT64));
 
 VOID OsSchedTimerBaseReset(UINT64 currTime);
 
+STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
+{
+    if (g_sysSchedStartTime == 0) {
+        return g_sysSchedStartTime;
+    }
+
+    return (OsGetCurrSysTimeCycle() - g_sysSchedStartTime);
+}
+
 /**
  * @ingroup los_sched
  * @brief Get the time, in nanoseconds, remaining before the next tick interrupt response.

kernel/include/los_sortlink.h

@@ -57,6 +57,15 @@ typedef struct {
 
 #define OS_SORT_LINK_INVALID_TIME ((UINT64)-1)
 #define SET_SORTLIST_VALUE(sortList, value) (((SortLinkList *)(sortList))->responseTime = (value))
+#define GET_SORTLIST_VALUE(sortList) (((SortLinkList *)(sortList))->responseTime)
+
+STATIC INLINE UINT64 OsSortLinkGetRemainTime(UINT64 currTime, const SortLinkList *targetSortList)
+{
+    if (currTime >= targetSortList->responseTime) {
+        return 0;
+    }
+    return (targetSortList->responseTime - currTime);
+}
 
 SortLinkAttribute *OsGetSortLinkAttribute(SortLinkType type);
 UINT64 OsGetNextExpireTime(UINT64 startTime);

kernel/include/los_swtmr.h

@@ -276,12 +276,12 @@ typedef struct tagSwTmrCtrl {
     UINT8               ucSensitive;    /* align enable                                          */
 #endif
     UINT32              usTimerID;      /* Software timer ID                                     */
-    UINT32              uwCount;        /* Times that a software timer works                     */
     UINT32              uwInterval;     /* Timeout interval of a periodic software timer         */
     UINT32              uwArg;          /* Parameter passed in when the callback function
                                            that handles software timer timeout is called         */
     SWTMR_PROC_FUNC     pfnHandler;     /* Callback function that handles software timer timeout */
     SortLinkList        stSortList;
+    UINT64              startTime;
 } SWTMR_CTRL_S;
 
 

kernel/src/los_sched.c

@@ -56,8 +56,18 @@ STATIC LOS_DL_LIST g_priQueueList[OS_PRIORITY_QUEUE_NUM];
 STATIC UINT32 g_queueBitmap;
 
 STATIC UINT32 g_schedResponseID = 0;
+STATIC UINT16 g_tickIntLock = 0;
+STATIC UINT64 g_tickStartTime = 0;
 STATIC UINT64 g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
 STATIC VOID (*SchedRealSleepTimeSet)(UINT64) = NULL;
+UINT64 g_sysSchedStartTime = 0;
+
+STATIC VOID OsSchedSetStartTime(UINT64 currCycle)
+{
+    if (g_sysSchedStartTime == 0) {
+        g_sysSchedStartTime = currCycle;
+    }
+}
 
 UINT32 OsSchedRealSleepTimeSet(VOID (*func)(UINT64))
 {
@@ -89,7 +99,7 @@ VOID OsSchedTimerBaseReset(UINT64 currTime)
 }
 #endif
 
-UINT64 OsGetCurrSchedTimeCycle(VOID)
+UINT64 OsGetCurrSysTimeCycle(VOID)
 {
 #if (LOSCFG_BASE_CORE_TICK_WTIMER == 1)
     return HalGetTickCycle(NULL);
@@ -124,42 +134,35 @@ STATIC INLINE VOID OsTimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime)
     taskCB->startTime = currTime;
 }
 
-STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate)
+STATIC INLINE VOID OsSchedTickReload(UINT64 nextResponseTime, UINT32 responseID, BOOL isTimeSlice, BOOL timeUpdate)
 {
-    UINT64 nextExpireTime = OsGetNextExpireTime(startTime);
+    UINT64 currTime, nextExpireTime;
-    UINT64 nextResponseTime;
+    UINT32 usedTime;
-    BOOL isTimeSlice = FALSE;
 
-    /* The current thread's time slice has been consumed, but the current system lock task cannot
+    currTime = OsGetCurrSchedTimeCycle();
-     * trigger the schedule to release the CPU
+    if (g_tickStartTime != 0) {
-     */
+        usedTime = currTime - g_tickStartTime;
-    if (taskEndTime < nextExpireTime) {
+        g_tickStartTime = 0;
-        nextExpireTime = taskEndTime;
+    } else {
-        isTimeSlice = TRUE;
+        usedTime = 0;
     }
 
-    if ((g_schedResponseTime > nextExpireTime) && ((g_schedResponseTime - nextExpireTime) >= OS_CYCLE_PER_TICK)) {
+    if ((nextResponseTime > usedTime) && ((nextResponseTime - usedTime) > OS_TICK_RESPONSE_PRECISION)) {
-        nextResponseTime = nextExpireTime - startTime;
+        nextResponseTime -= usedTime;
-        if (nextResponseTime > OS_TICK_RESPONSE_TIME_MAX) {
+    } else {
-            if (SchedRealSleepTimeSet != NULL) {
+        nextResponseTime = OS_TICK_RESPONSE_PRECISION;
-                SchedRealSleepTimeSet(nextResponseTime);
     }
-            nextResponseTime = OS_TICK_RESPONSE_TIME_MAX;
+
-            nextExpireTime = startTime + nextResponseTime;
+    nextExpireTime = currTime + nextResponseTime;
-        } else if (nextResponseTime < OS_CYCLE_PER_TICK) {
-            if (SchedRealSleepTimeSet != NULL) {
-                SchedRealSleepTimeSet(0);
-            }
-            nextResponseTime = OS_CYCLE_PER_TICK;
-            nextExpireTime = startTime + nextResponseTime;
     if (nextExpireTime >= g_schedResponseTime) {
         return;
     }
+
+#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
+    if (timeUpdate) {
+        g_schedTimerBase = OsGetCurrSysTimeCycle();
     }
-    } else {
+#endif
-        /* There is no point earlier than the current expiration date */
-        return;
-    }
 
     if (isTimeSlice) {
         /* The expiration time of the current system is the thread's slice expiration time */
@@ -167,26 +170,59 @@ STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID,
     } else {
         g_schedResponseID = OS_INVALID;
     }
-
     g_schedResponseTime = nextExpireTime;
-#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
-    if (timeUpdate) {
-        g_schedTimerBase = OsGetCurrSchedTimeCycle();
-    }
-#endif
     HalSysTickReload(nextResponseTime);
 }
 
+STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate)
+{
+    UINT64 nextExpireTime;
+    UINT64 nextResponseTime = 0;
+    BOOL isTimeSlice = FALSE;
+
+    nextExpireTime = OsGetNextExpireTime(startTime);
+    /* The response time of the task time slice is aligned to the next response time in the delay queue */
+    if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) {
+        nextExpireTime = taskEndTime;
+        isTimeSlice = TRUE;
+    }
+
+    if ((g_schedResponseTime > nextExpireTime) &&
+        ((g_schedResponseTime - nextExpireTime) >= OS_TICK_RESPONSE_PRECISION)) {
+        nextResponseTime = nextExpireTime - startTime;
+        if (nextResponseTime > OS_TICK_RESPONSE_TIME_MAX) {
+            if (SchedRealSleepTimeSet != NULL) {
+                SchedRealSleepTimeSet(nextResponseTime);
+            }
+            nextResponseTime = OS_TICK_RESPONSE_TIME_MAX;
+        }
+
+        if (SchedRealSleepTimeSet != NULL) {
+            SchedRealSleepTimeSet(0);
+        }
+    } else {
+        /* There is no point earlier than the current expiration date */
+        g_tickStartTime = 0;
+        return;
+    }
+
+    OsSchedTickReload(nextResponseTime, responseID, isTimeSlice, timeUpdate);
+}
+
 VOID OsSchedUpdateExpireTime(UINT64 startTime, BOOL timeUpdate)
 {
     UINT64 endTime;
     LosTaskCB *runTask = g_losTask.runTask;
 
+    if (!g_taskScheduled || g_tickIntLock) {
+        return;
+    }
+
     if (runTask->taskID != g_idleTaskID) {
         INT32 timeSlice = (runTask->timeSlice <= OS_TIME_SLICE_MIN) ? OS_SCHED_TIME_SLICES : runTask->timeSlice;
         endTime = startTime + timeSlice;
     } else {
-        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_CYCLE_PER_TICK;
+        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION;
     }
     OsSchedSetNextExpireTime(startTime, runTask->taskID, endTime, timeUpdate);
 }
@@ -448,6 +484,7 @@ VOID OsSchedStart(VOID)
     g_losTask.runTask = g_losTask.newTask;
 
     g_taskScheduled = 1;
+    OsSchedSetStartTime(OsGetCurrSysTimeCycle());
     newTask->startTime = OsGetCurrSchedTimeCycle();
     OsSchedTaskDeQueue(newTask);
 
@@ -491,7 +528,7 @@ BOOL OsSchedTaskSwitch(VOID)
     if (newTask->taskID != g_idleTaskID) {
         endTime = newTask->startTime + newTask->timeSlice;
     } else {
-        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_CYCLE_PER_TICK;
+        endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION;
     }
     OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, endTime, TRUE);
 
@@ -520,7 +557,6 @@ UINT64 LOS_SchedTickTimeoutNsGet(VOID)
 
 VOID LOS_SchedTickHandler(VOID)
 {
-    UINT64 currTime;
     BOOL needSched = FALSE;
 
     if (!g_taskScheduled) {
@@ -528,22 +564,23 @@ VOID LOS_SchedTickHandler(VOID)
     }
 
     UINT32 intSave = LOS_IntLock();
-
+    g_tickStartTime = OsGetCurrSchedTimeCycle();
     if (g_schedResponseID == OS_INVALID) {
+        g_tickIntLock++;
         if (g_swtmrScan != NULL) {
             needSched = g_swtmrScan();
         }
 
         needSched |= OsSchedScanTimerList();
+        g_tickIntLock--;
     }
 
     g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
     if (needSched && LOS_CHECK_SCHEDULE) {
         HalTaskSchedule();
     } else {
-        currTime = OsGetCurrSchedTimeCycle();
+        OsTimeSliceUpdate(g_losTask.runTask, g_tickStartTime);
-        OsTimeSliceUpdate(g_losTask.runTask, currTime);
+        OsSchedUpdateExpireTime(g_tickStartTime, TRUE);
-        OsSchedUpdateExpireTime(currTime, TRUE);
     }
 
     LOS_IntRestore(intSave);

kernel/src/los_sortlink.c

@@ -86,39 +86,19 @@ VOID OsDeleteNodeSortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortL
 
 STATIC INLINE UINT64 OsGetSortLinkNextExpireTime(SortLinkAttribute *sortHeader, UINT64 startTime)
 {
-    UINT64 expirTime = 0;
-    UINT64 nextExpirTime = 0;
     LOS_DL_LIST *head = &sortHeader->sortLink;
     LOS_DL_LIST *list = head->pstNext;
 
     if (LOS_ListEmpty(head)) {
-        return OS_SCHED_MAX_RESPONSE_TIME - OS_CYCLE_PER_TICK;
+        return OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION;
     }
 
-    do {
     SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
-        if (listSorted->responseTime <= startTime) {
+    if (listSorted->responseTime <= (startTime + OS_TICK_RESPONSE_PRECISION)) {
-            expirTime = startTime;
+        return startTime + OS_TICK_RESPONSE_PRECISION;
-            list = list->pstNext;
-        } else {
-            nextExpirTime = listSorted->responseTime;
-            break;
-        }
-    } while (list != head);
-
-    if (expirTime == 0) {
-        return nextExpirTime;
     }
 
-    if (nextExpirTime == 0) {
+    return listSorted->responseTime;
-        return expirTime;
-    }
-
-    if ((nextExpirTime - expirTime) <= OS_US_PER_TICK) {
-        return nextExpirTime;
-    }
-
-    return expirTime;
 }
 
 VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type)

kernel/src/los_swtmr.c

@@ -120,106 +120,107 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrTaskCreate(VOID)
 }
 
 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
-STATIC_INLINE UINT32 OsSwtmrCalcAlignCount(UINT64 currTime, UINT32 interval, UINT32 timerId)
+STATIC UINT64 OsSwtmrCalcStartTime(UINT64 currTime, SWTMR_CTRL_S *swtmr, const SWTMR_CTRL_S *alignSwtmr)
 {
-    UINT32 count;
+    UINT64 usedTime, startTime;
-
+    UINT64 alignEnd = (UINT64)alignSwtmr->uwInterval * OS_CYCLE_PER_TICK;
-    if (interval == 0) {
+    UINT64 swtmrTime = (UINT64)swtmr->uwInterval * OS_CYCLE_PER_TICK;
-        return interval;
+    UINT64 remainTime = OsSortLinkGetRemainTime(currTime, &alignSwtmr->stSortList);
+    if (remainTime == 0) {
+        startTime = GET_SORTLIST_VALUE(&alignSwtmr->stSortList);
+    } else {
+        usedTime = alignEnd - remainTime;
+        startTime = alignSwtmr->startTime + (usedTime / swtmrTime) * swtmrTime;
     }
-    SWTMR_CTRL_S *cur = g_swtmrCBArray + timerId % LOSCFG_BASE_CORE_SWTMR_LIMIT;
+
-    count = OsSortLinkGetTargetExpireTime(currTime, &cur->stSortList);
+    return startTime;
-    return (interval - (cur->uwInterval - count) % interval);
 }
 
-VOID OsSwtmrFindAlignPos(UINT64 currTime, SWTMR_CTRL_S *swtmr)
+UINT64 OsSwtmrFindAlignPos(UINT64 currTime, SWTMR_CTRL_S *swtmr)
 {
     SWTMR_CTRL_S *minInLarge = (SWTMR_CTRL_S *)NULL;
     SWTMR_CTRL_S *maxInLittle = (SWTMR_CTRL_S *)NULL;
-    UINT32 currSwtmrTimes, swtmrTimes;
     UINT32 minInLargeVal = OS_NULL_INT;
     UINT32 maxInLittleVal = OS_NULL_INT;
-
     LOS_DL_LIST *listHead = &g_swtmrSortLinkList->sortLink;
-    if (LOS_ListEmpty(listHead)) {
+    SwtmrAlignData swtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
-        return;
-    }
-
-    SwtmrAlignData currSwtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
-    currSwtmrTimes = currSwtmrAlgInfo.times;
     LOS_DL_LIST *listObject = listHead->pstNext;
 
+    if (LOS_ListEmpty(listHead)) {
+        goto RETURN_PERIOD;
+    }
+
     do {
         SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject, SortLinkList, sortLinkNode);
-        SWTMR_CTRL_S *cur = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
+        SWTMR_CTRL_S *swtmrListNode = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
-        SwtmrAlignData swtmrAlgInfo = g_swtmrAlignID[cur->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
+        SwtmrAlignData alignListNode = g_swtmrAlignID[swtmrListNode->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
+
         /* swtmr not start */
-        if ((swtmrAlgInfo.isAligned == 0) || (swtmrAlgInfo.canAlign == 0)) {
+        if ((alignListNode.isAligned == 0) || (alignListNode.canAlign == 0)) {
             goto CONTINUE_NEXT_NODE;
         }
-        /* find same interval timer, directly return */
-        if (cur->uwInterval == swtmr->uwInterval) {
-            swtmr->uwCount = OsSortLinkGetTargetExpireTime(currTime, &cur->stSortList);
-            return;
-        }
 
-        if ((currSwtmrAlgInfo.canMultiple != 1) || (swtmrAlgInfo.times == 0)) {
+        /* find same interval timer, directly return */
+        if (swtmrListNode->uwInterval == swtmr->uwInterval) {
+            return OsSwtmrCalcStartTime(currTime, swtmr, swtmrListNode);
+        }
+
+        if ((swtmrAlgInfo.canMultiple != 1) || (alignListNode.times == 0)) {
             goto CONTINUE_NEXT_NODE;
         }
-        swtmrTimes = swtmrAlgInfo.times;
+
-        if (currSwtmrTimes == 0) {
+        if (swtmrAlgInfo.times == 0) {
-            return;
+            goto RETURN_PERIOD;
         }
-        if ((swtmrTimes >= currSwtmrTimes) && ((swtmrTimes % currSwtmrTimes) == 0)) {
+
-            if (minInLargeVal > (swtmrTimes / currSwtmrTimes)) {
+        if ((alignListNode.times >= swtmrAlgInfo.times) && ((alignListNode.times % swtmrAlgInfo.times) == 0)) {
-                minInLargeVal = swtmrTimes / currSwtmrTimes;
+            if (minInLargeVal > (alignListNode.times / swtmrAlgInfo.times)) {
-                minInLarge = cur;
+                minInLargeVal = alignListNode.times / swtmrAlgInfo.times;
+                minInLarge = swtmrListNode;
             }
-        } else if ((swtmrTimes < currSwtmrTimes) && ((currSwtmrTimes % swtmrTimes) == 0)) {
+        } else if ((alignListNode.times < swtmrAlgInfo.times) && ((swtmrAlgInfo.times % alignListNode.times) == 0)) {
-            if (maxInLittleVal > (currSwtmrTimes / swtmrTimes)) {
+            if (maxInLittleVal > (swtmrAlgInfo.times / alignListNode.times)) {
-                maxInLittleVal = currSwtmrTimes / swtmrTimes;
+                maxInLittleVal = swtmrAlgInfo.times / alignListNode.times;
-                maxInLittle = cur;
+                maxInLittle = swtmrListNode;
             }
         }
+
 CONTINUE_NEXT_NODE:
         listObject = listObject->pstNext;
     } while (listObject != listHead);
 
     if (minInLarge != NULL) {
-        swtmr->uwCount = OsSwtmrCalcAlignCount(currTime, swtmr->uwInterval, minInLarge->usTimerID);
+        return OsSwtmrCalcStartTime(currTime, swtmr, minInLarge);
     } else if (maxInLittle != NULL) {
-        swtmr->uwCount = OsSortLinkGetTargetExpireTime(currTime, &maxInLittle->stSortList);
+        return OsSwtmrCalcStartTime(currTime, swtmr, maxInLittle);
     }
 
-    return;
+RETURN_PERIOD:
+    return currTime;
 }
 #endif
 
 /*****************************************************************************
 Function    : OsSwtmrStart
 Description : Start Software Timer
+Input       : currTime ------- Current system time
 Input       : swtmr ---------- Need to start Software Timer
 Output      : None
 Return      : None
 *****************************************************************************/
-LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr)
+LITE_OS_SEC_TEXT VOID OsSwtmrStart(UINT64 currTime, SWTMR_CTRL_S *swtmr)
 {
-    UINT64 currTime = OsGetCurrSchedTimeCycle();
-
-    swtmr->uwCount = swtmr->uwInterval;
     swtmr->ucState = OS_SWTMR_STATUS_TICKING;
 
 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
     if ((g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].canAlign == 1) &&
         (g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned == 0)) {
         g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 1;
-        OsSwtmrFindAlignPos(currTime, swtmr);
+        swtmr->startTime = OsSwtmrFindAlignPos(currTime, swtmr);
     }
 #endif
-    OsAdd2SortLink(&swtmr->stSortList, currTime, swtmr->uwCount, OS_SORT_LINK_SWTMR);
+    OsAdd2SortLink(&swtmr->stSortList, swtmr->startTime, swtmr->uwInterval, OS_SORT_LINK_SWTMR);
-    if (LOS_TaskIsRunning()) {
     OsSchedUpdateExpireTime(currTime, TRUE);
-    }
 }
 
 /*****************************************************************************
@@ -248,15 +249,13 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
     OsDeleteSortLink(&swtmr->stSortList, OS_SORT_LINK_SWTMR);
     swtmr->ucState = OS_SWTMR_STATUS_CREATED;
 
-    if (LOS_TaskIsRunning()) {
     OsSchedUpdateExpireTime(OsGetCurrSchedTimeCycle(), TRUE);
 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
     g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 0;
 #endif
-    }
 }
 
-STATIC VOID OsSwtmrTimeoutHandle(SWTMR_CTRL_S *swtmr)
+STATIC VOID OsSwtmrTimeoutHandle(UINT64 currTime, SWTMR_CTRL_S *swtmr)
 {
     SwtmrHandlerItem swtmrHandler;
 
@@ -272,7 +271,7 @@ STATIC VOID OsSwtmrTimeoutHandle(SWTMR_CTRL_S *swtmr)
             swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
         }
     } else if (swtmr->ucMode == LOS_SWTMR_MODE_PERIOD) {
-        OsSwtmrStart(swtmr);
+        OsSwtmrStart(currTime, swtmr);
     } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
         swtmr->ucState = OS_SWTMR_STATUS_CREATED;
     }
@@ -290,11 +289,12 @@ STATIC BOOL OsSwtmrScan(VOID)
     SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
     UINT64 currTime = OsGetCurrSchedTimeCycle();
     while (sortList->responseTime <= currTime) {
-        OsDeleteNodeSortLink(g_swtmrSortLinkList, sortList);
-
         SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
+        swtmr->startTime = GET_SORTLIST_VALUE(sortList);
+
+        OsDeleteNodeSortLink(g_swtmrSortLinkList, sortList);
         OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
-        OsSwtmrTimeoutHandle(swtmr);
+        OsSwtmrTimeoutHandle(currTime, swtmr);
 
         needSchedule = TRUE;
         if (LOS_ListEmpty(listObject)) {
@@ -468,7 +468,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
     swtmr->ucMode        = mode;
     swtmr->uwInterval    = interval;
     swtmr->pstNext       = (SWTMR_CTRL_S *)NULL;
-    swtmr->uwCount       = 0;
     swtmr->uwArg         = arg;
 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
     swtmr->ucRouses      = rouses;
@@ -523,7 +522,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT32 swtmrId)
             OsSwtmrStop(swtmr);
             /* fall through */
         case OS_SWTMR_STATUS_CREATED:
-            OsSwtmrStart(swtmr);
+            swtmr->startTime = OsGetCurrSchedTimeCycle();
+            OsSwtmrStart(swtmr->startTime, swtmr);
             break;
         default:
             ret = LOS_ERRNO_SWTMR_STATUS_INVALID;

kernel/src/los_tick.c

@@ -60,7 +60,7 @@ LITE_OS_SEC_TEXT VOID OsTickHandler(VOID)
 
 UINT64 LOS_SysCycleGet(VOID)
 {
-    return OsGetCurrSchedTimeCycle();
+    return OsGetCurrSysTimeCycle();
 }
 
 /*****************************************************************************

testsuits/sample/kernel/event/It_los_event_034.c

@@ -66,7 +66,9 @@ static UINT32 Testcase(VOID)
     LOS_SwtmrStart(swTmrID);
 
     LOS_TaskDelay(11); // 11, set delay time.
+    if (g_testCount < 10) { // 10, Here, assert that g_testCount is equal to 10.
         ICUNIT_GOTO_EQUAL(g_testCount, 10, g_testCount, EXIT); // 10, Here, assert that g_testCount is equal to 10.
+    }
 EXIT:
 
     LOS_SwtmrDelete(swTmrID);

testsuits/sample/kernel/sem/It_los_sem_010.c

@@ -44,9 +44,6 @@ static VOID HwiF01(void)
     UINT32 ret;
     TestHwiClear(HWI_NUM_TEST);
 
-    ret = LOS_SemPend(g_usSemID, LOS_WAIT_FOREVER);
-    ICUNIT_TRACK_EQUAL(ret, LOS_OK, ret);
-
     ret = LOS_SemPend(g_usSemID, LOS_WAIT_FOREVER);
     ICUNIT_TRACK_EQUAL(ret, LOS_ERRNO_SEM_PEND_INTERR, ret);
 

testsuits/sample/kernel/swtmr/It_los_swtmr_026.c

@@ -67,9 +67,10 @@ static UINT32 Testcase(VOID)
         ret = LOS_TaskDelay(10); // 10, set delay time.
         ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
+        if (g_testCount < (2 * i)) { // 2, assert that g_testCount is equal to this.
             // 2, assert that g_testCount is equal to this.
             ICUNIT_GOTO_EQUAL(g_testCount, 2 * i, g_testCount, EXIT);
-
+        }
         ret = LOS_SwtmrDelete(swTmrID);
         ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
     }

testsuits/sample/kernel/swtmr/It_los_swtmr_Align_008.c

@@ -64,11 +64,11 @@ static UINT32 Testcase(VOID)
 
     // 4, Timeout interval of a periodic software timer.
     ret = LOS_SwtmrCreate(4, LOS_SWTMR_MODE_PERIOD, Case1, &swtmrId1, 0xffff, OS_SWTMR_ROUSES_ALLOW,
-        OS_SWTMR_ALIGN_SENSITIVE);
+        OS_SWTMR_ALIGN_INSENSITIVE);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
     // 4, Timeout interval of a periodic software timer.
     ret = LOS_SwtmrCreate(4, LOS_SWTMR_MODE_PERIOD, Case2, &swtmrId2, 0xffff, OS_SWTMR_ROUSES_ALLOW,
-        OS_SWTMR_ALIGN_SENSITIVE);
+        OS_SWTMR_ALIGN_INSENSITIVE);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
     ret = LOS_SwtmrStart(swtmrId1);

testsuits/sample/kernel/swtmr/It_los_swtmr_Align_018.c

@@ -74,8 +74,10 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(20); // 20, set delay time.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
-    // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 1, Here, assert that g_testCount is equal to this .
-    ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
+
+    ret = LOS_TaskDelay(20); // 20, set delay time.
+    ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 3, Here, assert that g_testCount is equal to this .
 
     ret = LOS_SwtmrDelete(swtmrId1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -85,8 +87,7 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(20); // 20, set delay time.
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
-    // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount); // 3, Here, assert that g_testCount is equal to this .
-    ICUNIT_ASSERT_EQUAL(g_testCount, 2, g_testCount);
 
     return LOS_OK;
 

testsuits/sample/kernel/swtmr/It_los_swtmr_Align_020.c

@@ -82,9 +82,11 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(15); // 15, set delay time.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
-    // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 1, Here, assert that g_testCount is equal to this .
-    ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
+    ICUNIT_GOTO_EQUAL(g_swtmrCount1 - g_swtmrCount2, 1, g_swtmrCount1 - g_swtmrCount2, EXIT);
-    ICUNIT_GOTO_EQUAL(g_swtmrCount1 - g_swtmrCount2, 0, g_swtmrCount1 - g_swtmrCount2, EXIT);
+
+    ret = LOS_TaskDelay(20); // 20, set delay time.
+    ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 3, Here, assert that g_testCount is equal to this .
 
     ret = LOS_SwtmrDelete(swtmrId1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -94,8 +96,7 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(20); // 20, set delay time.
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
-    // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount); // 3, Here, assert that g_testCount is equal to this .
-    ICUNIT_ASSERT_EQUAL(g_testCount, 2, g_testCount);
 
     return LOS_OK;
 

testsuits/sample/kernel/swtmr/It_los_swtmr_Align_030.c

@@ -99,10 +99,17 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(20); // 20, set delay time.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
-    ICUNIT_GOTO_EQUAL(g_swtmrCount2 - g_swtmrCount1, 0, g_swtmrCount2 - g_swtmrCount1, EXIT);
+
-    ICUNIT_GOTO_EQUAL(g_swtmrCount3 - g_swtmrCount2, 0, g_swtmrCount3 - g_swtmrCount2, EXIT);
+    ICUNIT_GOTO_EQUAL(g_swtmrCount1, 1, g_swtmrCount1, EXIT); // 1, Here, assert that g_testCount is equal to this .
-    // 3, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount2, 0, g_swtmrCount2, EXIT); // 0, Here, assert that g_testCount is equal to this .
-    ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT);
+    ICUNIT_GOTO_EQUAL(g_swtmrCount3, 0, g_swtmrCount3, EXIT); // 0, Here, assert that g_testCount is equal to this .
+
+    ret = LOS_TaskDelay(60); // 60, set delay time.
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    ICUNIT_GOTO_EQUAL(g_swtmrCount1, 4, g_swtmrCount1, EXIT); // 4, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount2, 2, g_swtmrCount2, EXIT); // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount3, 1, g_swtmrCount3, EXIT); // 1, Here, assert that g_testCount is equal to this .
 
     ret = LOS_SwtmrDelete(swtmrId1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -113,11 +120,6 @@ static UINT32 Testcase(VOID)
     ret = LOS_SwtmrDelete(swtmrId3);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
 
-    ret = LOS_TaskDelay(20); // 20, set delay time.
-    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
-    // 3, Here, assert that g_testCount is equal to this .
-    ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount);
-
     return LOS_OK;
 
 EXIT:

testsuits/sample/kernel/swtmr/It_los_swtmr_Align_031.c

@@ -105,10 +105,16 @@ static UINT32 Testcase(VOID)
 
     ret = LOS_TaskDelay(10); // 10, set delay time.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
-    ICUNIT_GOTO_EQUAL(g_swtmrCount2 - g_swtmrCount2, 0, g_swtmrCount2 - g_swtmrCount1, EXIT);
+    ICUNIT_GOTO_EQUAL(g_swtmrCount1, 1, g_swtmrCount1, EXIT); // 1, Here, assert that g_testCount is equal to this .
-    ICUNIT_GOTO_EQUAL(g_swtmrCount3 - g_swtmrCount2, 0, g_swtmrCount3 - g_swtmrCount2, EXIT);
+    ICUNIT_GOTO_EQUAL(g_swtmrCount2, 0, g_swtmrCount2, EXIT); // 0, Here, assert that g_testCount is equal to this .
-    // 3, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount3, 0, g_swtmrCount3, EXIT); // 0, Here, assert that g_testCount is equal to this .
-    ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT);
+
+    ret = LOS_TaskDelay(60); // 60, set delay time.
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    ICUNIT_GOTO_EQUAL(g_swtmrCount1, 4, g_swtmrCount1, EXIT); // 4, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount2, 2, g_swtmrCount2, EXIT); // 2, Here, assert that g_testCount is equal to this .
+    ICUNIT_GOTO_EQUAL(g_swtmrCount3, 1, g_swtmrCount3, EXIT); // 1, Here, assert that g_testCount is equal to this .
 
     ret = LOS_SwtmrDelete(swtmrId1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -119,11 +125,6 @@ static UINT32 Testcase(VOID)
     ret = LOS_SwtmrDelete(swtmrId3);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
 
-    ret = LOS_TaskDelay(10); // 10, set delay time.
-    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
-    // 3, Here, assert that g_testCount is equal to this .
-    ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount);
-
     return LOS_OK;
 
 EXIT:

testsuits/sample/kernel/task/It_los_task_081.c

@@ -46,7 +46,7 @@ static VOID TaskF01(VOID)
     tick2 = LOS_TickCountGet();
     tick2 = tick2 - tick1;
 
-    if ((tick2 != 10) && (tick2 != 11)) { // 10, 11 delay time
+    if (tick2 < 10) { // 10, delay time
         ICUNIT_GOTO_EQUAL(tick2, 0, tick2, EXIT); // 0, Here, assert that result is equal to 0.
     }