diff --git a/components/power/los_pm.c b/components/power/los_pm.c index 9bc933f5fc6724f9dfe4d5814e1d76762180cf84..9f5f18769673f5be3ea2ec4b0cf3beb161b4cadf 100644 --- a/components/power/los_pm.c +++ b/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; diff --git a/kernel/include/los_config.h b/kernel/include/los_config.h index fec0de38b40e7102e8bc4b03d45be729165e75cc..722952c785ede1ac8d4c69aeb3d8e74b4dc91172 100644 --- a/kernel/include/los_config.h +++ b/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" diff --git a/kernel/include/los_sched.h b/kernel/include/los_sched.h index e7ac66e160b3af8b87825fdc8fe4daf244a98f0d..aef3bd48ab0f7669d8400e30ba8b40d4c968d136 100644 --- a/kernel/include/los_sched.h +++ b/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. diff --git a/kernel/include/los_sortlink.h b/kernel/include/los_sortlink.h index 2e0c5a85d6deb2c3c5133cc8ac5a27b179fb4616..517d91c82eabe7d6f0051dba9fa6dfacffeed070 100644 --- a/kernel/include/los_sortlink.h +++ b/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); diff --git a/kernel/include/los_swtmr.h b/kernel/include/los_swtmr.h index b86f1bf0a85f873a2aa9601c6fc30e672051ec99..c517c7a59dd59be90b39819490b8e55653c42527 100644 --- a/kernel/include/los_swtmr.h +++ b/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; diff --git a/kernel/src/los_sched.c b/kernel/src/los_sched.c index bd95f9d496a5641b0399d1b1258f92f9984ec9d4..d169fd720f9e89ccac20d633d95261296a11f530 100644 --- a/kernel/src/los_sched.c +++ b/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,57 +134,79 @@ STATIC INLINE VOID OsTimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime) taskCB->startTime = currTime; } +STATIC INLINE VOID OsSchedTickReload(UINT64 nextResponseTime, UINT32 responseID, BOOL isTimeSlice, BOOL timeUpdate) +{ + UINT64 currTime, nextExpireTime; + UINT32 usedTime; + + currTime = OsGetCurrSchedTimeCycle(); + if (g_tickStartTime != 0) { + usedTime = currTime - g_tickStartTime; + g_tickStartTime = 0; + } else { + usedTime = 0; + } + + if ((nextResponseTime > usedTime) && ((nextResponseTime - usedTime) > OS_TICK_RESPONSE_PRECISION)) { + nextResponseTime -= usedTime; + } else { + nextResponseTime = OS_TICK_RESPONSE_PRECISION; + } + + nextExpireTime = currTime + nextResponseTime; + if (nextExpireTime >= g_schedResponseTime) { + return; + } + +#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0) + if (timeUpdate) { + g_schedTimerBase = OsGetCurrSysTimeCycle(); + } +#endif + + if (isTimeSlice) { + /* The expiration time of the current system is the thread's slice expiration time */ + g_schedResponseID = responseID; + } else { + g_schedResponseID = OS_INVALID; + } + g_schedResponseTime = nextExpireTime; + HalSysTickReload(nextResponseTime); +} + STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate) { - UINT64 nextExpireTime = OsGetNextExpireTime(startTime); - UINT64 nextResponseTime; + UINT64 nextExpireTime; + UINT64 nextResponseTime = 0; BOOL isTimeSlice = FALSE; - /* The current thread's time slice has been consumed, but the current system lock task cannot - * trigger the schedule to release the CPU - */ - if (taskEndTime < nextExpireTime) { + 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_CYCLE_PER_TICK)) { + 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; - nextExpireTime = startTime + 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 (SchedRealSleepTimeSet != NULL) { + SchedRealSleepTimeSet(0); } } else { /* There is no point earlier than the current expiration date */ + g_tickStartTime = 0; return; } - if (isTimeSlice) { - /* The expiration time of the current system is the thread's slice expiration time */ - g_schedResponseID = responseID; - } else { - g_schedResponseID = OS_INVALID; - } - - g_schedResponseTime = nextExpireTime; -#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0) - if (timeUpdate) { - g_schedTimerBase = OsGetCurrSchedTimeCycle(); - } -#endif - HalSysTickReload(nextResponseTime); + OsSchedTickReload(nextResponseTime, responseID, isTimeSlice, timeUpdate); } VOID OsSchedUpdateExpireTime(UINT64 startTime, BOOL timeUpdate) @@ -182,11 +214,15 @@ 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, currTime); - OsSchedUpdateExpireTime(currTime, TRUE); + OsTimeSliceUpdate(g_losTask.runTask, g_tickStartTime); + OsSchedUpdateExpireTime(g_tickStartTime, TRUE); } LOS_IntRestore(intSave); diff --git a/kernel/src/los_sortlink.c b/kernel/src/los_sortlink.c index e1783063733f592a58ba10f105e25a722fdb2b15..8f772f7a377ed4f28853048710b5d7f598d99f6d 100644 --- a/kernel/src/los_sortlink.c +++ b/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) { - expirTime = startTime; - list = list->pstNext; - } else { - nextExpirTime = listSorted->responseTime; - break; - } - } while (list != head); - - if (expirTime == 0) { - return nextExpirTime; - } - - if (nextExpirTime == 0) { - return expirTime; - } - - if ((nextExpirTime - expirTime) <= OS_US_PER_TICK) { - return nextExpirTime; + SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode); + if (listSorted->responseTime <= (startTime + OS_TICK_RESPONSE_PRECISION)) { + return startTime + OS_TICK_RESPONSE_PRECISION; } - return expirTime; + return listSorted->responseTime; } VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type) diff --git a/kernel/src/los_swtmr.c b/kernel/src/los_swtmr.c index f0343c2fef554e7e44930b5e759aaa7bb685c4ae..f5bb7b01a78190ced095fea011d2dae317b9ec42 100644 --- a/kernel/src/los_swtmr.c +++ b/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; - - if (interval == 0) { - return interval; - } - SWTMR_CTRL_S *cur = g_swtmrCBArray + timerId % LOSCFG_BASE_CORE_SWTMR_LIMIT; - count = OsSortLinkGetTargetExpireTime(currTime, &cur->stSortList); - return (interval - (cur->uwInterval - count) % interval); + UINT64 usedTime, startTime; + UINT64 alignEnd = (UINT64)alignSwtmr->uwInterval * OS_CYCLE_PER_TICK; + UINT64 swtmrTime = (UINT64)swtmr->uwInterval * OS_CYCLE_PER_TICK; + 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; + } + + return startTime; } -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; + SwtmrAlignData swtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT]; + LOS_DL_LIST *listObject = listHead->pstNext; + if (LOS_ListEmpty(listHead)) { - return; + goto RETURN_PERIOD; } - SwtmrAlignData currSwtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT]; - currSwtmrTimes = currSwtmrAlgInfo.times; - LOS_DL_LIST *listObject = listHead->pstNext; - do { SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject, SortLinkList, sortLinkNode); - SWTMR_CTRL_S *cur = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList); - SwtmrAlignData swtmrAlgInfo = g_swtmrAlignID[cur->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT]; + SWTMR_CTRL_S *swtmrListNode = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList); + 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 (swtmrListNode->uwInterval == swtmr->uwInterval) { + return OsSwtmrCalcStartTime(currTime, swtmr, swtmrListNode); } - if ((currSwtmrAlgInfo.canMultiple != 1) || (swtmrAlgInfo.times == 0)) { + if ((swtmrAlgInfo.canMultiple != 1) || (alignListNode.times == 0)) { goto CONTINUE_NEXT_NODE; } - swtmrTimes = swtmrAlgInfo.times; - if (currSwtmrTimes == 0) { - return; + + if (swtmrAlgInfo.times == 0) { + goto RETURN_PERIOD; } - if ((swtmrTimes >= currSwtmrTimes) && ((swtmrTimes % currSwtmrTimes) == 0)) { - if (minInLargeVal > (swtmrTimes / currSwtmrTimes)) { - minInLargeVal = swtmrTimes / currSwtmrTimes; - minInLarge = cur; + + if ((alignListNode.times >= swtmrAlgInfo.times) && ((alignListNode.times % swtmrAlgInfo.times) == 0)) { + if (minInLargeVal > (alignListNode.times / swtmrAlgInfo.times)) { + minInLargeVal = alignListNode.times / swtmrAlgInfo.times; + minInLarge = swtmrListNode; } - } else if ((swtmrTimes < currSwtmrTimes) && ((currSwtmrTimes % swtmrTimes) == 0)) { - if (maxInLittleVal > (currSwtmrTimes / swtmrTimes)) { - maxInLittleVal = currSwtmrTimes / swtmrTimes; - maxInLittle = cur; + } else if ((alignListNode.times < swtmrAlgInfo.times) && ((swtmrAlgInfo.times % alignListNode.times) == 0)) { + if (maxInLittleVal > (swtmrAlgInfo.times / alignListNode.times)) { + maxInLittleVal = swtmrAlgInfo.times / alignListNode.times; + 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); - if (LOS_TaskIsRunning()) { - OsSchedUpdateExpireTime(currTime, TRUE); - } + OsAdd2SortLink(&swtmr->stSortList, swtmr->startTime, swtmr->uwInterval, OS_SORT_LINK_SWTMR); + 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); + OsSchedUpdateExpireTime(OsGetCurrSchedTimeCycle(), TRUE); #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) - g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 0; + 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; diff --git a/kernel/src/los_tick.c b/kernel/src/los_tick.c index 897a44e2d83b7e71931dfb3c984d36d60714a5fc..de6902814f8879b048eb6171b47eb64be64b02f8 100644 --- a/kernel/src/los_tick.c +++ b/kernel/src/los_tick.c @@ -60,7 +60,7 @@ LITE_OS_SEC_TEXT VOID OsTickHandler(VOID) UINT64 LOS_SysCycleGet(VOID) { - return OsGetCurrSchedTimeCycle(); + return OsGetCurrSysTimeCycle(); } /***************************************************************************** diff --git a/testsuits/sample/kernel/event/It_los_event_034.c b/testsuits/sample/kernel/event/It_los_event_034.c index adaa3715023fb53a9382f8e6cc78d566e042e7b0..07ae207173f076ebd8a48282d985e5e44e77269e 100644 --- a/testsuits/sample/kernel/event/It_los_event_034.c +++ b/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. - ICUNIT_GOTO_EQUAL(g_testCount, 10, g_testCount, EXIT); // 10, Here, assert that g_testCount is equal to 10. + 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); diff --git a/testsuits/sample/kernel/sem/It_los_sem_010.c b/testsuits/sample/kernel/sem/It_los_sem_010.c index 66b9385509ac8673ade654ae2b928b6bcad38652..f1e4a880284ded7145ad159ba7d6310ed8a1d7b5 100644 --- a/testsuits/sample/kernel/sem/It_los_sem_010.c +++ b/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); diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_026.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_026.c index 6827a0f2202ef093e6f18951db88896e4c4cfe62..09f4f21b14fe8b9ec2ff4e5b63359acd27554127 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_026.c +++ b/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); - // 2, assert that g_testCount is equal to this. - ICUNIT_GOTO_EQUAL(g_testCount, 2 * i, g_testCount, 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); } diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_008.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_008.c index 0c30801d1c2a22123eb7f67165d1d7678b83bf11..680793fa539f6f1fc813a8cb82aadc0932be21e5 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_008.c +++ b/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); diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_018.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_018.c index 52604c8af11c5a112a9bd184a64dcd6f330674cf..6d2b02c2025f7d9a67b1325892100775148194cf 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_018.c +++ b/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, 2, g_testCount, EXIT); + ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 1, Here, assert that g_testCount is equal to this . + + 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, 2, g_testCount); + ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount); // 3, Here, assert that g_testCount is equal to this . return LOS_OK; diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_020.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_020.c index 7518c6233276addaaa6c5e3347c1474291a41706..7a411b11434801f2812fc56840fd738f3c7b60d3 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_020.c +++ b/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, 2, g_testCount, EXIT); - ICUNIT_GOTO_EQUAL(g_swtmrCount1 - g_swtmrCount2, 0, g_swtmrCount1 - g_swtmrCount2, EXIT); + ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 1, Here, assert that g_testCount is equal to this . + ICUNIT_GOTO_EQUAL(g_swtmrCount1 - g_swtmrCount2, 1, 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, 2, g_testCount); + ICUNIT_ASSERT_EQUAL(g_testCount, 3, g_testCount); // 3, Here, assert that g_testCount is equal to this . return LOS_OK; diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_030.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_030.c index 1408b19ff915780974ff90aa4bb9df6cc983663d..20068e182c6e61efb40bf119ce20b59751da95f2 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_030.c +++ b/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); - // 3, Here, assert that g_testCount is equal to this . - ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); + + ICUNIT_GOTO_EQUAL(g_swtmrCount1, 1, g_swtmrCount1, EXIT); // 1, 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_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: diff --git a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_031.c b/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_031.c index daab584a715b7a8174d665d3e1a718160d6f9c87..b6c555cc3b813fe74a4c72cc92ca34521434a1b5 100644 --- a/testsuits/sample/kernel/swtmr/It_los_swtmr_Align_031.c +++ b/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_swtmrCount3 - g_swtmrCount2, 0, g_swtmrCount3 - g_swtmrCount2, EXIT); - // 3, Here, assert that g_testCount is equal to this . - ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); + ICUNIT_GOTO_EQUAL(g_swtmrCount1, 1, g_swtmrCount1, EXIT); // 1, 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_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); @@ -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: diff --git a/testsuits/sample/kernel/task/It_los_task_081.c b/testsuits/sample/kernel/task/It_los_task_081.c index d90f1196f9a82865869fb2c11948ec027e0b16eb..814164b53586882a0f13b8a29a36f2f8132737b6 100644 --- a/testsuits/sample/kernel/task/It_los_task_081.c +++ b/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. }