yystopf
/
openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Merge pull request !247 from zhushengle/tick_sched
This commit is contained in:
openharmony_ci 2021-08-10 06:16:34 +00:00 committed by Gitee
parent 7fe9cc9aa0 2118c84616
commit 11bca47b6e
18 changed files with 229 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
components/power/los_pm.c
View File

@ -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;

16
kernel/include/los_config.h
View File

@ -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"

15
kernel/include/los_sched.h
View File

@ -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.

9
kernel/include/los_sortlink.h
View File

@ -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);

2
kernel/include/los_swtmr.h
View File

@ -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;

123
kernel/src/los_sched.c
View File

@ -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,69 +134,95 @@ 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 nextResponseTime;
BOOL isTimeSlice = FALSE;
UINT64 currTime, nextExpireTime;
UINT32 usedTime;
/* 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 = taskEndTime;
isTimeSlice = TRUE;
currTime = OsGetCurrSchedTimeCycle();
if (g_tickStartTime != 0) {
usedTime = currTime - g_tickStartTime;
g_tickStartTime = 0;
} else {
usedTime = 0;
}
if ((g_schedResponseTime > nextExpireTime) && ((g_schedResponseTime - nextExpireTime) >= OS_CYCLE_PER_TICK)) {
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 ((nextResponseTime > usedTime) && ((nextResponseTime - usedTime) > OS_TICK_RESPONSE_PRECISION)) {
nextResponseTime -= usedTime;
} else {
/* There is no point earlier than the current expiration date */
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;
#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, currTime);
OsSchedUpdateExpireTime(currTime, TRUE);
OsTimeSliceUpdate(g_losTask.runTask, g_tickStartTime);
OsSchedUpdateExpireTime(g_tickStartTime, TRUE);
}
LOS_IntRestore(intSave);

30
kernel/src/los_sortlink.c
View File

@ -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;
SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
if (listSorted->responseTime <= (startTime + OS_TICK_RESPONSE_PRECISION)) {
return startTime + OS_TICK_RESPONSE_PRECISION;
}
if (nextExpirTime == 0) {
return expirTime;
}
if ((nextExpirTime - expirTime) <= OS_US_PER_TICK) {
return nextExpirTime;
}
return expirTime;
return listSorted->responseTime;
}
VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type)

120
kernel/src/los_swtmr.c
View File

@ -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;
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;
}
SWTMR_CTRL_S *cur = g_swtmrCBArray + timerId % LOSCFG_BASE_CORE_SWTMR_LIMIT;
count = OsSortLinkGetTargetExpireTime(currTime, &cur->stSortList);
return (interval - (cur->uwInterval - count) % interval);
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;
if (LOS_ListEmpty(listHead)) {
return;
}
SwtmrAlignData currSwtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
currSwtmrTimes = currSwtmrAlgInfo.times;
SwtmrAlignData swtmrAlgInfo = g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT];
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);
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 ((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) {
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;

2
kernel/src/los_tick.c
View File

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

4
testsuits/sample/kernel/event/It_los_event_034.c
View File

@ -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);

3
testsuits/sample/kernel/sem/It_los_sem_010.c
View File

@ -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);

7
testsuits/sample/kernel/swtmr/It_los_swtmr_026.c
View File

@ -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);
}

4
testsuits/sample/kernel/swtmr/It_los_swtmr_Align_008.c
View File

@ -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);

9
testsuits/sample/kernel/swtmr/It_los_swtmr_Align_018.c
View File

@ -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;

11
testsuits/sample/kernel/swtmr/It_los_swtmr_Align_020.c
View File

@ -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;

20
testsuits/sample/kernel/swtmr/It_los_swtmr_Align_030.c
View File

@ -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:

19
testsuits/sample/kernel/swtmr/It_los_swtmr_Align_031.c
View File

@ -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:

2
testsuits/sample/kernel/task/It_los_task_081.c
View File

@ -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.
}