los_swtmr.c 文件参考

软定时器主文件 更多...

浏览源代码.

结构体
struct	SwtmrRunqueue

函数
STATIC INLINE VOID	SwtmrDelete (SWTMR_CTRL_S *swtmr)
STATIC INLINE UINT64	SwtmrToStart (SWTMR_CTRL_S *swtmr, UINT16 cpuid)
LITE_OS_SEC_BSS	SPIN_LOCK_INIT (g_swtmrSpin)
	初始化软时钟自旋锁,只有SMP情况才需要,只要是自旋锁都是用于CPU多核的同步 更多...
BOOL	OsSwtmrDebugDataUsed (UINT32 swtmrID)
UINT32	OsSwtmrDebugDataGet (UINT32 swtmrID, SwtmrDebugData *data, UINT32 len, UINT8 *mode)
STATIC VOID	SwtmrDebugDataInit (VOID)
STATIC INLINE VOID	SwtmrDebugDataUpdate (SWTMR_CTRL_S *swtmr, UINT32 ticks, UINT32 times)
STATIC INLINE VOID	SwtmrDebugDataStart (SWTMR_CTRL_S *swtmr, UINT16 cpuid)
STATIC INLINE VOID	SwtmrDebugWaitTimeCalculate (UINT32 swtmrID, SwtmrHandlerItemPtr swtmrHandler)
STATIC INLINE VOID	SwtmrDebugDataClear (UINT32 swtmrID)
STATIC INLINE VOID	SwtmrHandler (SwtmrHandlerItemPtr swtmrHandle)
STATIC INLINE VOID	SwtmrWake (SwtmrRunqueue *srq, UINT64 startTime, SortLinkList *sortList)
STATIC INLINE VOID	ScanSwtmrTimeList (SwtmrRunqueue *srq)
STATIC VOID	SwtmrTask (VOID)
	软时钟的入口函数,拥有任务的最高优先级 0 级! 更多...
STATIC UINT32	SwtmrTaskCreate (UINT16 cpuid, UINT32 *swtmrTaskID)
	创建软时钟任务,每个cpu core都可以拥有自己的软时钟任务 更多...
UINT32	OsSwtmrTaskIDGetByCpuid (UINT16 cpuid)
BOOL	OsIsSwtmrTask (const LosTaskCB *taskCB)
LITE_OS_SEC_TEXT_INIT VOID	OsSwtmrRecycle (UINT32 processID)
	回收指定进程的软时钟 更多...
STATIC UINT32	SwtmrBaseInit (VOID)
	软时钟初始化 ,注意函数在多CPU情况下会执行多次 更多...
LITE_OS_SEC_TEXT_INIT UINT32	OsSwtmrInit (VOID)
STATIC INLINE VOID	FindIdleSwtmrRunqueue (UINT16 *idleCpuid)
STATIC INLINE VOID	AddSwtmr2TimeList (SortLinkList *node, UINT64 responseTime, UINT16 cpuid)
STATIC INLINE VOID	DeSwtmrFromTimeList (SortLinkList *node)
STATIC VOID	SwtmrAdjustCheck (UINT16 cpuid, UINT64 responseTime)
STATIC INLINE VOID	SwtmrStart (SWTMR_CTRL_S *swtmr)
STATIC INLINE VOID	SwtmrRestart (UINT64 startTime, SortLinkList *sortList, UINT16 cpuid)
VOID	OsSwtmrResponseTimeReset (UINT64 startTime)
STATIC INLINE BOOL	SwtmrRunqueueFind (SortLinkAttribute *swtmrSortLink, SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
STATIC BOOL	SwtmrTimeListFind (SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
BOOL	OsSwtmrWorkQueueFind (SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
LITE_OS_SEC_TEXT UINT32	OsSwtmrGetNextTimeout (VOID)
	Scan a software timer. 更多...
STATIC VOID	SwtmrStop (SWTMR_CTRL_S *swtmr)
LITE_OS_SEC_TEXT STATIC UINT32	OsSwtmrTimeGet (const SWTMR_CTRL_S *swtmr)
LITE_OS_SEC_TEXT_INIT UINT32	LOS_SwtmrCreate (UINT32 interval, UINT8 mode, SWTMR_PROC_FUNC handler, UINT16 *swtmrID, UINTPTR arg)
	创建定时器，设置定时器的定时时长、定时器模式、回调函数，并返回定时器ID 更多...
LITE_OS_SEC_TEXT UINT32	LOS_SwtmrStart (UINT16 swtmrID)
	接口函数 启动定时器 参数定时任务ID 更多...
LITE_OS_SEC_TEXT UINT32	LOS_SwtmrStop (UINT16 swtmrID)
	接口函数 停止定时器 参数定时任务ID 更多...
LITE_OS_SEC_TEXT UINT32	LOS_SwtmrTimeGet (UINT16 swtmrID, UINT32 *tick)
	接口函数 获得软件定时器剩余Tick数 通过 *tick 带走 更多...
LITE_OS_SEC_TEXT UINT32	LOS_SwtmrDelete (UINT16 swtmrID)
	接口函数 删除定时器 更多...

变量
LITE_OS_SEC_BSS SWTMR_CTRL_S *	g_swtmrCBArray = NULL
LITE_OS_SEC_BSS UINT8 *	g_swtmrHandlerPool = NULL
LITE_OS_SEC_BSS LOS_DL_LIST	g_swtmrFreeList
STATIC SwtmrRunqueue	g_swtmrRunqueue [LOSCFG_KERNEL_CORE_NUM]
STATIC SwtmrDebugData *	g_swtmrDebugData = NULL

详细描述

软定时器主文件

注意

基本概念 
    软件定时器，是基于系统Tick时钟中断且由软件来模拟的定时器。当经过设定的Tick数后，会触发用户自定义的回调函数。
    硬件定时器受硬件的限制，数量上不足以满足用户的实际需求。因此为了满足用户需求，提供更多的定时器，
    软件定时器功能，支持如下特性：
        创建软件定时器。
        启动软件定时器。
        停止软件定时器。
        删除软件定时器。
        获取软件定时器剩余Tick数。
        可配置支持的软件定时器个数。
        
    运作机制 
        软件定时器是系统资源，在模块初始化的时候已经分配了一块连续内存。
        软件定时器使用了系统的一个队列和一个任务资源，软件定时器的触发遵循队列规则，
        先进先出。定时时间短的定时器总是比定时时间长的靠近队列头，满足优先触发的准则。
        软件定时器以Tick为基本计时单位，当创建并启动一个软件定时器时，Huawei LiteOS会根据 
        当前系统Tick时间及设置的定时时长确定该定时器的到期Tick时间，并将该定时器控制结构挂入计时全局链表。
        当Tick中断到来时，在Tick中断处理函数中扫描软件定时器的计时全局链表，检查是否有定时器超时，
        若有则将超时的定时器记录下来。Tick中断处理函数结束后，软件定时器任务（优先级为最高）
        被唤醒，在该任务中调用已经记录下来的定时器的回调函数。
 
    定时器状态 
        OS_SWTMR_STATUS_UNUSED（定时器未使用）
        系统在定时器模块初始化时，会将系统中所有定时器资源初始化成该状态。
 
        OS_SWTMR_STATUS_TICKING（定时器处于计数状态）
        在定时器创建后调用LOS_SwtmrStart接口启动，定时器将变成该状态，是定时器运行时的状态。
 
        OS_SWTMR_STATUS_CREATED（定时器创建后未启动，或已停止）
        定时器创建后，不处于计数状态时，定时器将变成该状态。
 
    软件定时器提供了三类模式：
        单次触发定时器，这类定时器在启动后只会触发一次定时器事件，然后定时器自动删除。
        周期触发定时器，这类定时器会周期性的触发定时器事件，直到用户手动停止定时器，否则将永远持续执行下去。
        单次触发定时器，但这类定时器超时触发后不会自动删除，需要调用定时器删除接口删除定时器。
 
    使用场景 
        创建一个单次触发的定时器，超时后执行用户自定义的回调函数。
        创建一个周期性触发的定时器，超时后执行用户自定义的回调函数。
 
     软件定时器的典型开发流程 
         通过make menuconfig配置软件定时器 
         创建定时器LOS_SwtmrCreate，设置定时器的定时时长、定时器模式、超时后的回调函数。
         启动定时器LOS_SwtmrStart。
         获得软件定时器剩余Tick数LOS_SwtmrTimeGet。
         停止定时器LOS_SwtmrStop。
         删除定时器LOS_SwtmrDelete。
 
     注意事项 
         软件定时器的回调函数中不应执行过多操作，不建议使用可能引起任务挂起或者阻塞的接口或操作， 
         如果使用会导致软件定时器响应不及时，造成的影响无法确定。
         软件定时器使用了系统的一个队列和一个任务资源。软件定时器任务的优先级设定为0，且不允许修改 。
         系统可配置的软件定时器个数是指：整个系统可使用的软件定时器总个数，并非用户可使用的软件定时器个数。
         例如：系统多占用一个软件定时器，那么用户能使用的软件定时器资源就会减少一个。
         创建单次不自删除属性的定时器，用户需要自行调用定时器删除接口删除定时器，回收定时器资源，避免资源泄露。
         软件定时器的定时精度与系统Tick时钟的周期有关。

在文件 los_swtmr.c 中定义.

函数说明

AddSwtmr2TimeList()

STATIC INLINE VOID AddSwtmr2TimeList	(	SortLinkList *	node,
		UINT64	responseTime,
		UINT16	cpuid
	)

在文件 los_swtmr.c 第 491 行定义.

{
    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
    OsAdd2SortLink(&srq->swtmrSortLink, node, responseTime, cpuid);
}

函数调用图:

这是这个函数的调用关系图:

DeSwtmrFromTimeList()

STATIC INLINE VOID DeSwtmrFromTimeList

(

SortLinkList *

node

)

在文件 los_swtmr.c 第 497 行定义.

{
#ifdef LOSCFG_KERNEL_SMP
    UINT16 cpuid = OsGetSortLinkNodeCpuid(node);
#else
    UINT16 cpuid = 0;
#endif
    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
    OsDeleteFromSortLink(&srq->swtmrSortLink, node);
    return;
}

函数调用图:

这是这个函数的调用关系图:

FindIdleSwtmrRunqueue()

STATIC INLINE VOID FindIdleSwtmrRunqueue

(

UINT16 *

idleCpuid

)

在文件 los_swtmr.c 第 474 行定义.

{
    SwtmrRunqueue *idleRq = &g_swtmrRunqueue[0];
    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->swtmrSortLink);
    UINT16 cpuid = 1;
    do {
        SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
        UINT32 temp = OsGetSortLinkNodeNum(&srq->swtmrSortLink);
        if (nodeNum > temp) {
            *idleCpuid = cpuid;
            nodeNum = temp;
        }
        cpuid++;
    } while (cpuid < LOSCFG_KERNEL_CORE_NUM);
}

函数调用图:

这是这个函数的调用关系图:

OsIsSwtmrTask()

BOOL OsIsSwtmrTask

(

const LosTaskCB *

taskCB

)

在文件 los_swtmr.c 第 383 行定义.

{
    if (taskCB->taskEntry == (TSK_ENTRY_FUNC)SwtmrTask) {
        return TRUE;
    }
    return FALSE;
}

函数调用图:

这是这个函数的调用关系图:

OsSwtmrDebugDataGet()

UINT32 OsSwtmrDebugDataGet	(	UINT32	swtmrID,
		SwtmrDebugData *	data,
		UINT32	len,
		UINT8 *	mode
	)

在文件 los_swtmr.c 第 142 行定义.

{
    UINT32 intSave;
    errno_t ret;
 
    if ((swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) || (data == NULL) ||
        (mode == NULL) || (len < sizeof(SwtmrDebugData))) {
        return LOS_NOK;
    }
 
    SWTMR_CTRL_S *swtmr = &g_swtmrCBArray[swtmrID];
    SWTMR_LOCK(intSave);
    ret = memcpy_s(data, len, &g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData));
    *mode = swtmr->ucMode;
    SWTMR_UNLOCK(intSave);
    if (ret != EOK) {
        return LOS_NOK;
    }
    return LOS_OK;
}

这是这个函数的调用关系图:

OsSwtmrDebugDataUsed()

BOOL OsSwtmrDebugDataUsed

(

UINT32

swtmrID

)

在文件 los_swtmr.c 第 133 行定义.

{
    if (swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) {
        return FALSE;
    }
 
    return g_swtmrDebugData[swtmrID].swtmrUsed;
}

这是这个函数的调用关系图:

OsSwtmrGetNextTimeout()

LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout

(

VOID

)

Scan a software timer.

Description:

• This API is used to scan a software timer when a Tick interrupt occurs and determine whether the software timer expires.

注意

• None.

参数

None.

返回值

None.

Dependency:

• los_swtmr_pri.h: the header file that contains the API declaration.

参见

LOS_SwtmrStop

在文件 los_swtmr.c 第 675 行定义.

{
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    SwtmrRunqueue *srq = &g_swtmrRunqueue[ArchCurrCpuid()];
    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &srq->swtmrSortLink) / OS_CYCLE_PER_TICK);
    if (time > OS_INVALID_VALUE) {
        time = OS_INVALID_VALUE;
    }
    return (UINT32)time;
}

函数调用图:

OsSwtmrInit()

LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit

(

VOID

)

在文件 los_swtmr.c 第 441 行定义.

{
    UINT32 ret;
    UINT32 cpuid = ArchCurrCpuid();
    UINT32 swtmrTaskID;
 
    if (cpuid == 0) {
        ret = SwtmrBaseInit();
        if (ret != LOS_OK) {
            goto ERROR;
        }
    }
 
    ret = SwtmrTaskCreate(cpuid, &swtmrTaskID);
    if (ret != LOS_OK) {
        ret = LOS_ERRNO_SWTMR_TASK_CREATE_FAILED;
        goto ERROR;
    }
 
    SwtmrRunqueue *srq = &g_swtmrRunqueue[cpuid];
    srq->swtmrTask = OsGetTaskCB(swtmrTaskID);
    return LOS_OK;
 
ERROR:
    PRINT_ERR("OsSwtmrInit error! ret = %u\n", ret);
    (VOID)LOS_MemFree(m_aucSysMem0, g_swtmrCBArray);
    g_swtmrCBArray = NULL;
    (VOID)LOS_MemFree(m_aucSysMem1, g_swtmrHandlerPool);
    g_swtmrHandlerPool = NULL;
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsSwtmrRecycle()

LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle

(

UINT32

processID

)

回收指定进程的软时钟

在文件 los_swtmr.c 第 391 行定义.

{
    for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {//一个进程往往会有多个定时器
        if (g_swtmrCBArray[index].uwOwnerPid == processID) {//找到一个
            LOS_SwtmrDelete(index);//删除定时器
        }
    }
}

函数调用图:

这是这个函数的调用关系图:

OsSwtmrResponseTimeReset()

VOID OsSwtmrResponseTimeReset

(

UINT64

startTime

)

在文件 los_swtmr.c 第 610 行定义.

{
    UINT16 cpuid = ArchCurrCpuid();
    SortLinkAttribute *swtmrSortLink = &g_swtmrRunqueue[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);
}

函数调用图:

这是这个函数的调用关系图:

OsSwtmrTaskIDGetByCpuid()

UINT32 OsSwtmrTaskIDGetByCpuid

(

UINT16

cpuid

)

在文件 los_swtmr.c 第 378 行定义.

{
    return g_swtmrRunqueue[cpuid].swtmrTask->taskID;
}

OsSwtmrTimeGet()

LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet

(

const SWTMR_CTRL_S *

swtmr

)

在文件 los_swtmr.c 第 702 行定义.

{
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    UINT64 time = (OsSortLinkGetTargetExpireTime(currTime, &swtmr->stSortList) / OS_CYCLE_PER_TICK);
    if (time > OS_INVALID_VALUE) {
        time = OS_INVALID_VALUE;
    }
    return (UINT32)time;
}

函数调用图:

这是这个函数的调用关系图:

OsSwtmrWorkQueueFind()

BOOL OsSwtmrWorkQueueFind	(	SCHED_TL_FIND_FUNC	checkFunc,
		UINTPTR	arg
	)

在文件 los_swtmr.c 第 661 行定义.

{
    UINT32 intSave;
 
    SWTMR_LOCK(intSave);
    BOOL find = SwtmrTimeListFind(checkFunc, arg);
    SWTMR_UNLOCK(intSave);
    return find;
}

函数调用图:

ScanSwtmrTimeList()

STATIC INLINE VOID ScanSwtmrTimeList

(

SwtmrRunqueue *

srq

)

在文件 los_swtmr.c 第 282 行定义.

{
    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;
}

函数调用图:

这是这个函数的调用关系图:

SPIN_LOCK_INIT()

LITE_OS_SEC_BSS SPIN_LOCK_INIT

(

g_swtmrSpin

)

初始化软时钟自旋锁,只有SMP情况才需要,只要是自旋锁都是用于CPU多核的同步

SwtmrAdjustCheck()

STATIC VOID SwtmrAdjustCheck	(	UINT16	cpuid,
		UINT64	responseTime
	)

在文件 los_swtmr.c 第 509 行定义.

{
    UINT32 ret;
    UINT32 intSave;
    SwtmrRunqueue *srq = &g_swtmrRunqueue[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 = OsSchedTimeoutQueueAdjust(srq->swtmrTask, responseTime);
    SCHEDULER_UNLOCK(intSave);
    if (ret != LOS_OK) {
        return;
    }
 
    if (cpuid == ArchCurrCpuid()) {
        OsSchedExpireTimeUpdate();
    } else {
        LOS_MpSchedule(CPUID_TO_AFFI_MASK(cpuid));
    }
}

函数调用图:

这是这个函数的调用关系图:

SwtmrBaseInit()

STATIC UINT32 SwtmrBaseInit

(

VOID

)

软时钟初始化 ,注意函数在多CPU情况下会执行多次

在文件 los_swtmr.c 第 400 行定义.

{
    UINT32 ret;
    UINT32 size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
    SWTMR_CTRL_S *swtmr = (SWTMR_CTRL_S *)LOS_MemAlloc(m_aucSysMem0, size); /* system resident resource */
    if (swtmr == NULL) {
        return LOS_ERRNO_SWTMR_NO_MEMORY;
    }
 
    (VOID)memset_s(swtmr, size, 0, size);//清0
    g_swtmrCBArray = swtmr;//软时钟
    LOS_ListInit(&g_swtmrFreeList);//初始化空闲链表
    for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
            swtmr->usTimerID = index;//按顺序赋值
            LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);//通过sortLinkNode将节点挂到空闲链表 
    }
    //想要用静态内存池管理,就必须要使用LOS_MEMBOX_SIZE来计算申请的内存大小,因为需要点前缀内存承载头部信息.
    size = LOS_MEMBOX_SIZE(sizeof(SwtmrHandlerItem), OS_SWTMR_HANDLE_QUEUE_SIZE);//规划一片内存区域作为软时钟处理函数的静态内存池。
    g_swtmrHandlerPool = (UINT8 *)LOS_MemAlloc(m_aucSysMem1, size); /* system resident resource */
    if (g_swtmrHandlerPool == NULL) {
        return LOS_ERRNO_SWTMR_NO_MEMORY;
    }
 
    ret = LOS_MemboxInit(g_swtmrHandlerPool, size, sizeof(SwtmrHandlerItem));
    if (ret != LOS_OK) {
        return LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
    }
 
    for (UINT16 index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
        SwtmrRunqueue *srq = &g_swtmrRunqueue[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;
    }
 
    SwtmrDebugDataInit();
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

SwtmrDebugDataClear()

STATIC INLINE VOID SwtmrDebugDataClear

(

UINT32

swtmrID

)

在文件 los_swtmr.c 第 216 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    (VOID)memset_s(&g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData), 0, sizeof(SwtmrDebugData));
#endif
}

这是这个函数的调用关系图:

SwtmrDebugDataInit()

STATIC VOID SwtmrDebugDataInit

(

VOID

)

在文件 los_swtmr.c 第 164 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    UINT32 size = sizeof(SwtmrDebugData) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
    g_swtmrDebugData = (SwtmrDebugData *)LOS_MemAlloc(m_aucSysMem1, size);
    if (g_swtmrDebugData == NULL) {
        PRINT_ERR("SwtmrDebugDataInit malloc failed!\n");
        return;
    }
    (VOID)memset_s(g_swtmrDebugData, size, 0, size);
#endif
}

函数调用图:

这是这个函数的调用关系图:

SwtmrDebugDataStart()

STATIC INLINE VOID SwtmrDebugDataStart	(	SWTMR_CTRL_S *	swtmr,
		UINT16	cpuid
	)

在文件 los_swtmr.c 第 190 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
    data->swtmrUsed = TRUE;
    data->handler = swtmr->pfnHandler;
    data->cpuid = cpuid;
#endif
}

这是这个函数的调用关系图:

SwtmrDebugDataUpdate()

STATIC INLINE VOID SwtmrDebugDataUpdate	(	SWTMR_CTRL_S *	swtmr,
		UINT32	ticks,
		UINT32	times
	)

在文件 los_swtmr.c 第 177 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
    if (data->period != ticks) {
        (VOID)memset_s(&data->base, sizeof(SwtmrDebugBase), 0, sizeof(SwtmrDebugBase));
        data->period = ticks;
    }
    data->base.startTime = swtmr->startTime;
    data->base.times += times;
#endif
}

函数调用图:

这是这个函数的调用关系图:

SwtmrDebugWaitTimeCalculate()

STATIC INLINE VOID SwtmrDebugWaitTimeCalculate	(	UINT32	swtmrID,
		SwtmrHandlerItemPtr	swtmrHandler
	)

在文件 los_swtmr.c 第 200 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrID].base;
    swtmrHandler->swtmrID = swtmrID;
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    UINT64 waitTime = currTime - data->startTime;
    data->waitTime += waitTime;
    if (waitTime > data->waitTimeMax) {
        data->waitTimeMax = waitTime;
    }
    data->readyStartTime = currTime;
    data->waitCount++;
#endif
}

函数调用图:

这是这个函数的调用关系图:

SwtmrDelete()

STATIC INLINE VOID SwtmrDelete

(

SWTMR_CTRL_S *

swtmr

)

在文件 los_swtmr.c 第 590 行定义.

{
    /* insert to free list */
    LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);//直接插入空闲链表中,回收再利用
    swtmr->ucState = OS_SWTMR_STATUS_UNUSED;//又干净着呢
    swtmr->uwOwnerPid = 0;//谁拥有这个定时器? 是 0号进程
    SwtmrDebugDataClear(swtmr->usTimerID);
}

函数调用图:

这是这个函数的调用关系图:

SwtmrHandler()

STATIC INLINE VOID SwtmrHandler

(

SwtmrHandlerItemPtr

swtmrHandle

)

在文件 los_swtmr.c 第 223 行定义.

{
#ifdef LOSCFG_SWTMR_DEBUG
    UINT32 intSave;
    SwtmrDebugBase *data = &g_swtmrDebugData[swtmrHandle->swtmrID].base;
    UINT64 startTime = OsGetCurrSchedTimeCycle();
#endif
    swtmrHandle->handler(swtmrHandle->arg);
#ifdef LOSCFG_SWTMR_DEBUG
    UINT64 runTime = OsGetCurrSchedTimeCycle() - startTime;
    SWTMR_LOCK(intSave);
    data->runTime += runTime;
    if (runTime > data->runTimeMax) {
        data->runTimeMax = runTime;
    }
    runTime = startTime - data->readyStartTime;
    data->readyTime += runTime;
    if (runTime > data->readyTimeMax) {
        data->readyTimeMax = runTime;
    }
    data->runCount++;
    SWTMR_UNLOCK(intSave);
#endif
}

函数调用图:

这是这个函数的调用关系图:

SwtmrRestart()

STATIC INLINE VOID SwtmrRestart	(	UINT64	startTime,
		SortLinkList *	sortList,
		UINT16	cpuid
	)

在文件 los_swtmr.c 第 599 行定义.

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

函数调用图:

这是这个函数的调用关系图:

SwtmrRunqueueFind()

STATIC INLINE BOOL SwtmrRunqueueFind	(	SortLinkAttribute *	swtmrSortLink,
		SCHED_TL_FIND_FUNC	checkFunc,
		UINTPTR	arg
	)

在文件 los_swtmr.c 第 631 行定义.

{
    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;
}

函数调用图:

这是这个函数的调用关系图:

SwtmrStart()

STATIC INLINE VOID SwtmrStart

(

SWTMR_CTRL_S *

swtmr

)

在文件 los_swtmr.c 第 571 行定义.

{
    UINT64 responseTime;
    UINT16 idleCpu = 0;
#ifdef LOSCFG_KERNEL_SMP
    FindIdleSwtmrRunqueue(&idleCpu);
#endif
    swtmr->startTime = OsGetCurrSchedTimeCycle();
    responseTime = SwtmrToStart(swtmr, idleCpu);
 
    SwtmrDebugDataStart(swtmr, idleCpu);
 
    SwtmrAdjustCheck(idleCpu, responseTime);
}

函数调用图:

这是这个函数的调用关系图:

SwtmrStop()

STATIC VOID SwtmrStop

(

SWTMR_CTRL_S *

swtmr

)

在文件 los_swtmr.c 第 690 行定义.

{
    swtmr->ucState = OS_SWTMR_STATUS_CREATED;
    swtmr->uwOverrun = 0;
 
    DeSwtmrFromTimeList(&swtmr->stSortList);
}

函数调用图:

这是这个函数的调用关系图:

SwtmrTask()

STATIC VOID SwtmrTask

(

VOID

)

软时钟的入口函数,拥有任务的最高优先级 0 级!

返回

LITE_OS_SEC_TEXT

在文件 los_swtmr.c 第 325 行定义.

{
    SwtmrHandlerItem swtmrHandle;
    UINT32 intSave;
    UINT64 waitTime;
 
    SwtmrRunqueue *srq = &g_swtmrRunqueue[ArchCurrCpuid()];
    LOS_DL_LIST *head = &srq->swtmrHandlerQueue;
    for (;;) {//死循环获取队列item,一直读干净为止
        waitTime = OsSortLinkGetNextExpireTime(OsGetCurrSchedTimeCycle(), &srq->swtmrSortLink);
        if (waitTime != 0) {
            SCHEDULER_LOCK(intSave);
            srq->swtmrTask->ops->delay(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);
            }
        }
    }

函数调用图:

这是这个函数的调用关系图:

SwtmrTaskCreate()

STATIC UINT32 SwtmrTaskCreate	(	UINT16	cpuid,
		UINT32 *	swtmrTaskID
	)

创建软时钟任务,每个cpu core都可以拥有自己的软时钟任务

在文件 los_swtmr.c 第 356 行定义.

{
    UINT32 ret;
    TSK_INIT_PARAM_S swtmrTask;
 
    (VOID)memset_s(&swtmrTask, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));//清0
    swtmrTask.pfnTaskEntry = (TSK_ENTRY_FUNC)SwtmrTask;//入口函数
    swtmrTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;//16K默认内核任务栈
    swtmrTask.pcName = "Swt_Task";//任务名称
    swtmrTask.usTaskPrio = 0;//哇塞! 逮到一个最高优先级的任务 @note_thinking 这里应该用 OS_TASK_PRIORITY_HIGHEST 表示
    swtmrTask.uwResved = LOS_TASK_STATUS_DETACHED;//分离模式
#ifdef LOSCFG_KERNEL_SMP
    swtmrTask.usCpuAffiMask   = CPUID_TO_AFFI_MASK(cpuid);//交给当前CPU执行这个任务
#endif
    ret = LOS_TaskCreate(swtmrTaskID, &swtmrTask);//创建任务并申请调度
    if (ret == LOS_OK) {
        OS_TCB_FROM_TID(*swtmrTaskID)->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;//告知这是一个系统任务
    }
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

SwtmrTimeListFind()

STATIC BOOL SwtmrTimeListFind	(	SCHED_TL_FIND_FUNC	checkFunc,
		UINTPTR	arg
	)

在文件 los_swtmr.c 第 650 行定义.

{
    for (UINT16 cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
        SortLinkAttribute *swtmrSortLink = &g_swtmrRunqueue[ArchCurrCpuid()].swtmrSortLink;
        if (SwtmrRunqueueFind(swtmrSortLink, checkFunc, arg)) {
            return TRUE;
        }
    }
    return FALSE;
}

函数调用图:

这是这个函数的调用关系图:

SwtmrToStart()

STATIC UINT64 SwtmrToStart	(	SWTMR_CTRL_S *	swtmr,
		UINT16	cpuid
	)

在文件 los_swtmr.c 第 538 行定义.

{
    UINT32 ticks;
    UINT32 times = 0;
 
    if ((swtmr->uwOverrun == 0) && ((swtmr->ucMode == LOS_SWTMR_MODE_ONCE) ||
        (swtmr->ucMode == LOS_SWTMR_MODE_OPP) ||
        (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE))) {//如果是一次性的定时器
        ticks = swtmr->uwExpiry; //获取时间间隔
    } else {
        ticks = swtmr->uwInterval;//获取周期性定时器时间间隔
    }
    swtmr->ucState = OS_SWTMR_STATUS_TICKING;//计数状态
 
    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;
}

函数调用图:

这是这个函数的调用关系图:

SwtmrWake()

STATIC INLINE VOID SwtmrWake	(	SwtmrRunqueue *	srq,
		UINT64	startTime,
		SortLinkList *	sortList
	)

在文件 los_swtmr.c 第 248 行定义.

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

函数调用图:

这是这个函数的调用关系图:

变量说明

g_swtmrCBArray

LITE_OS_SEC_BSS SWTMR_CTRL_S* g_swtmrCBArray = NULL

First address in Timer memory space
定时器池

在文件 los_swtmr.c 第 112 行定义.

g_swtmrDebugData

STATIC SwtmrDebugData* g_swtmrDebugData = NULL

在文件 los_swtmr.c 第 131 行定义.

g_swtmrFreeList

LITE_OS_SEC_BSS LOS_DL_LIST g_swtmrFreeList

Free list of Software Timer
空闲定时器链表

在文件 los_swtmr.c 第 114 行定义.

g_swtmrHandlerPool

LITE_OS_SEC_BSS UINT8* g_swtmrHandlerPool = NULL

Pool of Swtmr Handler
用于注册软时钟的回调函数

在文件 los_swtmr.c 第 113 行定义.

g_swtmrRunqueue

STATIC SwtmrRunqueue g_swtmrRunqueue[LOSCFG_KERNEL_CORE_NUM]

在文件 los_swtmr.c 第 127 行定义.