los_cpup.c 文件参考

http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-debug-process-cpu.html 更多...

浏览源代码.

函数
STATIC UINT64	OsGetCpuCycle (VOID)
LITE_OS_SEC_TEXT_INIT VOID	OsCpupGuard (VOID)
LITE_OS_SEC_TEXT_INIT UINT32	OsCpupGuardCreator (VOID)
	创建cpu使用统计定时器 更多...
	LOS_MODULE_INIT (OsCpupGuardCreator, LOS_INIT_LEVEL_KMOD_TASK)
LITE_OS_SEC_TEXT_INIT UINT32	OsCpupInit (VOID)
	LOS_MODULE_INIT (OsCpupInit, LOS_INIT_LEVEL_KMOD_EXTENDED)
STATIC VOID	OsResetCpup (OsCpupBase *cpup, UINT64 cycle)
LITE_OS_SEC_TEXT_INIT VOID	LOS_CpupReset (VOID)
	Reset the data of CPU usage. 更多...
VOID	OsCpupCycleEndStart (UINT32 runTaskID, UINT32 newTaskID)
LITE_OS_SEC_TEXT_MINOR STATIC VOID	OsCpupGetPos (UINT16 mode, UINT16 *curPosPointer, UINT16 *prePosPointer)
STATIC INLINE UINT32	OsCalculateCpupUsage (const OsCpupBase *cpup, UINT16 pos, UINT16 prePos, UINT64 allCycle)
STATIC UINT32	OsHistorySysCpuUsageUnsafe (UINT16 mode)
LITE_OS_SEC_TEXT_MINOR UINT32	LOS_HistorySysCpuUsage (UINT16 mode)
	获取系统历史CPU占用率 指周期时间内系统的CPU占用率，用于表示系统一段时间内的闲忙程度，也表示CPU的负载情况。系统CPU 占用率的有效表示范围为0～100，其精度（可通过配置调整）为百分比。100表示系统满负荷运转。 更多...
STATIC UINT32	OsHistoryProcessCpuUsageUnsafe (UINT32 pid, UINT16 mode)
LITE_OS_SEC_TEXT_MINOR UINT32	LOS_HistoryProcessCpuUsage (UINT32 pid, UINT16 mode)
	获取指定进程历史CPU占用率 指单个进程的CPU占用率，用于表示单个进程在一段时间内的闲忙程度。进程CPU占用率的有效表示范围为0～100， 其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该进程。 更多...
STATIC UINT32	OsHistoryTaskCpuUsageUnsafe (UINT32 tid, UINT16 mode)
LITE_OS_SEC_TEXT_MINOR UINT32	LOS_HistoryTaskCpuUsage (UINT32 tid, UINT16 mode)
	获取指定任务历史CPU占用率 指单个任务的CPU占用率，用于表示单个任务在一段时间内的闲忙程度。任务CPU占用率的有效表示范围为0～100， 其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该任务。 更多...
STATIC UINT32	OsCpupUsageParamCheckAndReset (CPUP_INFO_S *cpupInfo, UINT32 len, UINT32 number)
LITE_OS_SEC_TEXT_MINOR UINT32	OsGetAllProcessCpuUsageUnsafe (UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
LITE_OS_SEC_TEXT_MINOR UINT32	LOS_GetAllProcessCpuUsage (UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
	获取系统所有进程的历史CPU占用率 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsGetAllProcessAndTaskCpuUsageUnsafe (UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
LITE_OS_SEC_TEXT_MINOR VOID	OsCpupIrqStart (UINT16 cpuid)
LITE_OS_SEC_TEXT_MINOR VOID	OsCpupIrqEnd (UINT16 cpuid, UINT32 intNum)
LITE_OS_SEC_TEXT_MINOR OsIrqCpupCB *	OsGetIrqCpupArrayBase (VOID)
LITE_OS_SEC_TEXT_MINOR UINT32	OsGetAllIrqCpuUsageUnsafe (UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
LITE_OS_SEC_TEXT_MINOR UINT32	LOS_GetAllIrqCpuUsage (UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
	获取系统所有中断的历史CPU占用率 指单个中断的CPU占用率，用于表示单个中断在一段时间内的闲忙程度。中断CPU占用率的有效表示范围为0～100， 其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该中断。 更多...

变量
LITE_OS_SEC_BSS STATIC UINT16	cpupSwtmrID
	监测CPU使用情况定时器s 更多...
LITE_OS_SEC_BSS STATIC UINT16	cpupInitFlg = 0
LITE_OS_SEC_BSS OsIrqCpupCB *	g_irqCpup = NULL
LITE_OS_SEC_BSS STATIC UINT32	cpupMaxNum
LITE_OS_SEC_BSS STATIC UINT16	cpupHisPos = 0
LITE_OS_SEC_BSS STATIC UINT64	cpuHistoryTime [OS_CPUP_HISTORY_RECORD_NUM+1]
LITE_OS_SEC_BSS STATIC UINT32	runningTasks [LOSCFG_KERNEL_CORE_NUM]
LITE_OS_SEC_BSS STATIC UINT64	cpupStartCycles = 0
	记录 更多...
LITE_OS_SEC_BSS UINT64	timeInIrqSwitch [LOSCFG_KERNEL_CORE_NUM]
LITE_OS_SEC_BSS STATIC UINT64	cpupIntTimeStart [LOSCFG_KERNEL_CORE_NUM]

详细描述

http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-debug-process-cpu.html

基本概念
    CPU（中央处理器，Central Processing Unit）占用率分为系统CPU占用率、进程CPU占用率、任务CPU占用率
    和中断CPU占用率。用户通过系统级的CPU占用率，判断当前系统负载是否超出设计规格。通过系统中各个
    进程/任务/中断的CPU占用情况，判断各个进程/任务/中断的CPU占用率是否符合设计的预期。
    
       系统CPU占用率（CPU Percent）

       指周期时间内系统的CPU占用率，用于表示系统一段时间内的闲忙程度，也表示CPU的负载情况。系统CPU占用率
       的有效表示范围为0～100，其精度（可通过配置调整）为百分比。100表示系统满负荷运转。
    
       进程CPU占用率
       
       指单个进程的CPU占用率，用于表示单个进程在一段时间内的闲忙程度。进程CPU占用率的有效表示范围为0～100，
       其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该进程。
       
       任务CPU占用率
       
       指单个任务的CPU占用率，用于表示单个任务在一段时间内的闲忙程度。任务CPU占用率的有效表示范围为0～100，
       其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该任务。
       
       中断CPU占用率
       
       指单个中断的CPU占用率，用于表示单个中断在一段时间内的闲忙程度。中断CPU占用率的有效表示范围为0～100，
       其精度（可通过配置调整）为百分比。100表示在一段时间内系统一直在运行该中断。

运行机制
    OpenHarmony LiteOS-A内核CPUP（CPU Percent，CPU占用率）模块采用进程、任务和中断级记录的方式，在进程/任务切换时，
    记录进程/任务启动时间，进程/任务切出或者退出时，系统会累加整个进程/任务的占用时间; 在执行中断时系统会累加记录
    每个中断的执行时间。
    
    OpenHarmony 提供以下四种CPU占用率的信息查询：
    
       系统CPU占用率
       进程CPU占用率
       任务CPU占用率
       中断CPU占用率
       
    CPU占用率的计算方法：
    
    系统CPU占用率=系统中除idle任务外其他任务运行总时间/系统运行总时间
    
    进程CPU占用率=进程运行总时间/系统运行总时间
    
    任务CPU占用率=任务运行总时间/系统运行总时间
    
    中断CPU占用率=中断运行总时间/系统运行总时间
    
开发流程
    CPU占用率的典型开发流程：
    
    调用获取系统历史CPU占用率函数LOS_HistorySysCpuUsage。
    
    调用获取指定进程历史CPU占用率函数LOS_HistoryProcessCpuUsage。
    
    若进程已创建，则关中断，根据不同模式正常获取，恢复中断；
    若进程未创建，则返回错误码；
    调用获取所有进程CPU占用率函数LOS_GetAllProcessCpuUsage。
    
    若CPUP已初始化，则关中断，根据不同模式正常获取，恢复中断；
    若CPUP未初始化或有非法入参，则返回错误码；
    调用获取指定任务历史CPU占用率函数LOS_HistoryTaskCpuUsage。
    
    若任务已创建，则关中断，根据不同模式正常获取，恢复中断；
    若任务未创建，则返回错误码；
    调用获取所有中断CPU占用率函数LOS_GetAllIrqCpuUsage。
    
    若CPUP已初始化，则关中断，根据不同模式正常获取，恢复中断；
    若CPUP未初始化或有非法入参，则返回错误码；

注意

版本

作者

weharmonyos.com | 鸿蒙研究站 | 每天死磕一点点

日期

2021-11-21

在文件 los_cpup.c 中定义.

函数说明

LOS_MODULE_INIT() [1/2]

LOS_MODULE_INIT	(	OsCpupGuardCreator	,
		LOS_INIT_LEVEL_KMOD_TASK
	)

LOS_MODULE_INIT() [2/2]

LOS_MODULE_INIT	(	OsCpupInit	,
		LOS_INIT_LEVEL_KMOD_EXTENDED
	)

OsCalculateCpupUsage()

STATIC INLINE UINT32 OsCalculateCpupUsage	(	const OsCpupBase *	cpup,
		UINT16	pos,
		UINT16	prePos,
		UINT64	allCycle
	)

在文件 los_cpup.c 第 396 行定义.

{
    UINT32 usage = 0;
    UINT64 cpuCycle = cpup->historyTime[pos] - cpup->historyTime[prePos];
 
    if (allCycle) {
        usage = (UINT32)((LOS_CPUP_SINGLE_CORE_PRECISION * cpuCycle) / allCycle);
    }
    return usage;
}

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

OsCpupCycleEndStart()

VOID OsCpupCycleEndStart	(	UINT32	runTaskID,
		UINT32	newTaskID
	)

在文件 los_cpup.c 第 331 行定义.

{
    /* OsCurrTaskGet and OsCurrProcessGet are not allowed to be called. */
    LosTaskCB *runTask = OS_TCB_FROM_TID(runTaskID);
    OsCpupBase *runTaskCpup = &runTask->taskCpup;
    OsCpupBase *newTaskCpup = (OsCpupBase *)&(OS_TCB_FROM_TID(newTaskID)->taskCpup);
    OsCpupBase *processCpup = OS_PCB_FROM_PID(runTask->processID)->processCpup;
    UINT64 cpuCycle, cycleIncrement;
    UINT16 cpuid = ArchCurrCpuid();
 
    if (cpupInitFlg == 0) {
        return;
    }
 
    cpuCycle = OsGetCpuCycle();
    if (runTaskCpup->startTime != 0) {
        cycleIncrement = cpuCycle - runTaskCpup->startTime;
#ifdef LOSCFG_CPUP_INCLUDE_IRQ
        cycleIncrement -= timeInIrqSwitch[cpuid];
        timeInIrqSwitch[cpuid] = 0;
#endif
        runTaskCpup->allTime += cycleIncrement;
        if (processCpup != NULL) {
            processCpup->allTime += cycleIncrement;
        }
        runTaskCpup->startTime = 0;
    }
 
    newTaskCpup->startTime = cpuCycle;
    runningTasks[cpuid] = newTaskID;
}

函数调用图:

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

OsCpupGetPos()

LITE_OS_SEC_TEXT_MINOR STATIC VOID OsCpupGetPos	(	UINT16	mode,
		UINT16 *	curPosPointer,
		UINT16 *	prePosPointer
	)

在文件 los_cpup.c 第 363 行定义.

{
    UINT16 curPos;
    UINT16 tmpPos;
    UINT16 prePos;
 
    tmpPos = cpupHisPos;
    curPos = CPUP_PRE_POS(tmpPos);
 
    /*
     * The current postion has nothing to do with the CPUP modes,
     * however, the previous postion differs.
     */
    switch (mode) {
        case CPUP_LAST_ONE_SECONDS:
            prePos = CPUP_PRE_POS(curPos);
            break;
        case CPUP_LAST_TEN_SECONDS:
            prePos = tmpPos;
            break;
        case CPUP_ALL_TIME:
            /* fall-through */
        default:
            prePos = OS_CPUP_HISTORY_RECORD_NUM;
            break;
    }
 
    *curPosPointer = curPos;
    *prePosPointer = prePos;
 
    return;
}

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

OsCpupGuard()

LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard

(

VOID

)

在文件 los_cpup.c 第 166 行定义.

{
    UINT16 prevPos;
    UINT32 loop;
    UINT32 runTaskID;
    UINT32 intSave;
    UINT64 cycle, cycleIncrement;
    LosTaskCB *taskCB = NULL;
    LosProcessCB *processCB = NULL;
 
    SCHEDULER_LOCK(intSave);
 
    cycle = OsGetCpuCycle();
    prevPos = cpupHisPos;
    cpupHisPos = CPUP_POST_POS(cpupHisPos);
    cpuHistoryTime[prevPos] = cycle;
 
#ifdef LOSCFG_CPUP_INCLUDE_IRQ
    for (loop = 0; loop < cpupMaxNum; loop++) {
        if (g_irqCpup[loop].status == OS_CPUP_UNUSED) {
            continue;
        }
        g_irqCpup[loop].cpup.historyTime[prevPos] = g_irqCpup[loop].cpup.allTime;
    }
#endif
 
    for (loop = 0; loop < g_processMaxNum; loop++) {
        processCB = OS_PCB_FROM_PID(loop);
        if (processCB->processCpup == NULL) {
            continue;
        }
        processCB->processCpup->historyTime[prevPos] = processCB->processCpup->allTime;
    }
 
    for (loop = 0; loop < g_taskMaxNum; loop++) {
        taskCB = OS_TCB_FROM_TID(loop);
        taskCB->taskCpup.historyTime[prevPos] = taskCB->taskCpup.allTime;
    }
 
    for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
        runTaskID = runningTasks[loop];
        if (runTaskID == INVALID_ID) {
            continue;
        }
        taskCB = OS_TCB_FROM_TID(runTaskID);
 
        /* reacquire the cycle to prevent flip */
        cycle = OsGetCpuCycle();
        cycleIncrement = cycle - taskCB->taskCpup.startTime;
#ifdef LOSCFG_CPUP_INCLUDE_IRQ
        cycleIncrement -= timeInIrqSwitch[loop];
#endif
        taskCB->taskCpup.historyTime[prevPos] += cycleIncrement;
        processCB = OS_PCB_FROM_PID(taskCB->processID);
        processCB->processCpup->historyTime[prevPos] += cycleIncrement;
    }
 
    SCHEDULER_UNLOCK(intSave);
}

函数调用图:

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

OsCpupGuardCreator()

LITE_OS_SEC_TEXT_INIT UINT32 OsCpupGuardCreator

(

VOID

)

创建cpu使用统计定时器

在文件 los_cpup.c 第 226 行定义.

{
    (VOID)LOS_SwtmrCreate(LOSCFG_BASE_CORE_TICK_PER_SECOND, LOS_SWTMR_MODE_PERIOD,
                          (SWTMR_PROC_FUNC)OsCpupGuard, &cpupSwtmrID, 0);
 
    (VOID)LOS_SwtmrStart(cpupSwtmrID);
 
    return LOS_OK;
}

函数调用图:

OsCpupInit()

LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit

(

VOID

)

在文件 los_cpup.c 第 242 行定义.

{
    UINT16 loop;
#ifdef LOSCFG_CPUP_INCLUDE_IRQ
    UINT32 size;
 
    cpupMaxNum = OS_HWI_MAX_NUM * LOSCFG_KERNEL_CORE_NUM;
 
    /* every process has only one record, and it won't operated at the same time */
    size = cpupMaxNum * sizeof(OsIrqCpupCB);
    g_irqCpup = (OsIrqCpupCB *)LOS_MemAlloc(m_aucSysMem0, size);
    if (g_irqCpup == NULL) {
        PRINT_ERR("OsCpupInit error\n");
        return LOS_ERRNO_CPUP_NO_MEMORY;
    }
 
    (VOID)memset_s(g_irqCpup, size, 0, size);
#endif
 
    for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
        runningTasks[loop] = INVALID_ID;
    }
    cpupInitFlg = 1;
    return LOS_OK;
}

函数调用图:

OsCpupIrqEnd()

LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd	(	UINT16	cpuid,
		UINT32	intNum
	)

在文件 los_cpup.c 第 645 行定义.

{
    UINT32 high;
    UINT32 low;
    UINT64 intTimeEnd;
    UINT64 usedTime;
 
    LOS_GetCpuCycle(&high, &low);
    intTimeEnd = ((UINT64)high << HIGH_BITS) + low;
    OsIrqCpupCB *irqCb = &g_irqCpup[(intNum * LOSCFG_KERNEL_CORE_NUM) + cpuid];
    irqCb->id = intNum;
    irqCb->status = OS_CPUP_USED;
    usedTime = intTimeEnd - cpupIntTimeStart[cpuid];
    timeInIrqSwitch[cpuid] += usedTime;
    irqCb->cpup.allTime += usedTime;
    if (irqCb->count <= 100) { /* Take 100 samples */
        irqCb->allTime += usedTime;
        irqCb->count++;
    } else {
        irqCb->allTime = 0;
        irqCb->count = 0;
    }
    if (usedTime > irqCb->timeMax) {
        irqCb->timeMax = usedTime;
    }
    return;
}

函数调用图:

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

OsCpupIrqStart()

LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart

(

UINT16

cpuid

)

在文件 los_cpup.c 第 635 行定义.

{
    UINT32 high;
    UINT32 low;
 
    LOS_GetCpuCycle(&high, &low);
    cpupIntTimeStart[cpuid] = ((UINT64)high << HIGH_BITS) + low;
    return;
}

函数调用图:

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

OsCpupUsageParamCheckAndReset()

STATIC UINT32 OsCpupUsageParamCheckAndReset	(	CPUP_INFO_S *	cpupInfo,
		UINT32	len,
		UINT32	number
	)

在文件 los_cpup.c 第 541 行定义.

{
    if (cpupInitFlg == 0) {
        return LOS_ERRNO_CPUP_NO_INIT;
    }
 
    if ((cpupInfo == NULL) || (len < (sizeof(CPUP_INFO_S) * number))) {
        return LOS_ERRNO_CPUP_PTR_ERR;
    }
 
    (VOID)memset_s(cpupInfo, len, 0, len);
    return LOS_OK;
}

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

OsGetAllIrqCpuUsageUnsafe()

LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllIrqCpuUsageUnsafe	(	UINT16	mode,
		CPUP_INFO_S *	cpupInfo,
		UINT32	len
	)

在文件 los_cpup.c 第 678 行定义.

{
    UINT16 pos, prePos;
    UINT64 cpuAllCycle;
    UINT32 loop;
    UINT32 ret;
 
    ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, cpupMaxNum);
    if (ret != LOS_OK) {
        return ret;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    for (loop = 0; loop < cpupMaxNum; loop++) {
        if (g_irqCpup[loop].status == OS_CPUP_UNUSED) {
            continue;
        }
 
        cpupInfo[loop].usage = OsCalculateCpupUsage(&g_irqCpup[loop].cpup, pos, prePos, cpuAllCycle);
        cpupInfo[loop].status = g_irqCpup[loop].status;
    }
 
    return LOS_OK;
}

函数调用图:

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

OsGetAllProcessAndTaskCpuUsageUnsafe()

LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe	(	UINT16	mode,
		CPUP_INFO_S *	cpupInfo,
		UINT32	len
	)

在文件 los_cpup.c 第 595 行定义.

{
    UINT64 cpuAllCycle;
    UINT16 pos, prePos;
    UINT32 taskID;
    UINT32 ret;
    LosTaskCB *taskCB = NULL;
    OsCpupBase *processCpupBase = NULL;
    CPUP_INFO_S *processCpup = cpupInfo;
    CPUP_INFO_S *taskCpup = (CPUP_INFO_S *)((UINTPTR)cpupInfo + sizeof(CPUP_INFO_S) * g_processMaxNum);
 
    ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_taskMaxNum + g_processMaxNum);
    if (ret != LOS_OK) {
        return ret;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    for (taskID = 0; taskID < g_taskMaxNum; taskID++) {
        taskCB = OS_TCB_FROM_TID(taskID);
        if (OsTaskIsUnused(taskCB)) {
            continue;
        }
 
        taskCpup[taskID].usage = OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
        taskCpup[taskID].status = OS_CPUP_USED;
        if (processCpup[taskCB->processID].status == OS_CPUP_UNUSED) {
            processCpupBase = OS_PCB_FROM_PID(taskCB->processID)->processCpup;
            if (processCpupBase != NULL) {
                processCpup[taskCB->processID].usage = OsCalculateCpupUsage(processCpupBase, pos, prePos, cpuAllCycle);
                processCpup[taskCB->processID].status = OS_CPUP_USED;
            }
        }
    }
 
    return LOS_OK;
}

函数调用图:

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

OsGetAllProcessCpuUsageUnsafe()

LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessCpuUsageUnsafe	(	UINT16	mode,
		CPUP_INFO_S *	cpupInfo,
		UINT32	len
	)

在文件 los_cpup.c 第 555 行定义.

{
    LosProcessCB *processCB = NULL;
    UINT64 cpuAllCycle;
    UINT16 pos, prePos;
    UINT32 processID;
    UINT32 ret;
 
    ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_processMaxNum);
    if (ret != LOS_OK) {
        return ret;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    for (processID = 0; processID < g_processMaxNum; processID++) {
        processCB = OS_PCB_FROM_PID(processID);
        if (OsProcessIsUnused(processCB) || (processCB->processCpup == NULL)) {
            continue;
        }
 
        cpupInfo[processID].usage = OsCalculateCpupUsage(processCB->processCpup, pos, prePos, cpuAllCycle);
        cpupInfo[processID].status = OS_CPUP_USED;
    }
 
    return LOS_OK;
}

函数调用图:

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

OsGetCpuCycle()

STATIC UINT64 OsGetCpuCycle

(

VOID

)

在文件 los_cpup.c 第 145 行定义.

{
    UINT32 high;
    UINT32 low;
    UINT64 cycles;//周期数用 64位计算，读取分成高低位
 
    LOS_GetCpuCycle(&high, &low);//将64位拆成两个32位
    cycles = ((UINT64)high << HIGH_BITS) + low;
    if (cpupStartCycles == 0) {
        cpupStartCycles = cycles;
    }
 
    /*
     * The cycles should keep growing, if the checking failed,
     * it mean LOS_GetCpuCycle has the problem which should be fixed.
     */
    LOS_ASSERT(cycles >= cpupStartCycles);
 
    return (cycles - cpupStartCycles);
}

函数调用图:

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

OsGetIrqCpupArrayBase()

LITE_OS_SEC_TEXT_MINOR OsIrqCpupCB * OsGetIrqCpupArrayBase

(

VOID

)

在文件 los_cpup.c 第 673 行定义.

{
    return g_irqCpup;
}

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

OsHistoryProcessCpuUsageUnsafe()

STATIC UINT32 OsHistoryProcessCpuUsageUnsafe	(	UINT32	pid,
		UINT16	mode
	)

在文件 los_cpup.c 第 447 行定义.

{
    LosProcessCB *processCB = NULL;
    UINT64 cpuAllCycle;
    UINT16 pos, prePos;
 
    if (cpupInitFlg == 0) {
        return LOS_ERRNO_CPUP_NO_INIT;
    }
 
    if (OS_PID_CHECK_INVALID(pid)) {
        return LOS_ERRNO_CPUP_ID_INVALID;
    }
 
    processCB = OS_PCB_FROM_PID(pid);
    if (OsProcessIsUnused(processCB)) {
        return LOS_ERRNO_CPUP_NO_CREATED;
    }
 
    if (processCB->processCpup == NULL) {
        return LOS_ERRNO_CPUP_ID_INVALID;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    return OsCalculateCpupUsage(processCB->processCpup, pos, prePos, cpuAllCycle);
}

函数调用图:

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

OsHistorySysCpuUsageUnsafe()

STATIC UINT32 OsHistorySysCpuUsageUnsafe

(

UINT16

mode

)

在文件 los_cpup.c 第 407 行定义.

{
    UINT64 cpuAllCycle;
    UINT16 pos;
    UINT16 prePos;
    UINT32 idleProcessID;
    OsCpupBase *processCpup = NULL;
 
    if (cpupInitFlg == 0) {
        return LOS_ERRNO_CPUP_NO_INIT;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    idleProcessID = OsGetIdleProcessID();
    processCpup = OS_PCB_FROM_PID(idleProcessID)->processCpup;
    return (LOS_CPUP_PRECISION - OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle));
}

函数调用图:

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

OsHistoryTaskCpuUsageUnsafe()

STATIC UINT32 OsHistoryTaskCpuUsageUnsafe	(	UINT32	tid,
		UINT16	mode
	)

在文件 los_cpup.c 第 496 行定义.

{
    LosTaskCB *taskCB = NULL;
    UINT64 cpuAllCycle;
    UINT16 pos, prePos;
 
    if (cpupInitFlg == 0) {
        return LOS_ERRNO_CPUP_NO_INIT;
    }
 
    if (OS_TID_CHECK_INVALID(tid)) {
        return LOS_ERRNO_CPUP_ID_INVALID;
    }
 
    taskCB = OS_TCB_FROM_TID(tid);
    if (OsTaskIsUnused(taskCB)) {
        return LOS_ERRNO_CPUP_NO_CREATED;
    }
 
    OsCpupGetPos(mode, &pos, &prePos);
    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
    return OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
}

函数调用图:

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

OsResetCpup()

STATIC VOID OsResetCpup	(	OsCpupBase *	cpup,
		UINT64	cycle
	)

在文件 los_cpup.c 第 270 行定义.

{
    UINT16 loop;
 
    cpup->startTime = cycle;
    cpup->allTime = cycle;
    for (loop = 0; loop < (OS_CPUP_HISTORY_RECORD_NUM + 1); loop++) {
        cpup->historyTime[loop] = cycle;
    }
}

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

变量说明

cpuHistoryTime

LITE_OS_SEC_BSS STATIC UINT64 cpuHistoryTime[OS_CPUP_HISTORY_RECORD_NUM+1]

在文件 los_cpup.c 第 128 行定义.

cpupHisPos

LITE_OS_SEC_BSS STATIC UINT16 cpupHisPos = 0

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

cpupInitFlg

LITE_OS_SEC_BSS STATIC UINT16 cpupInitFlg = 0

在文件 los_cpup.c 第 124 行定义.

cpupIntTimeStart

LITE_OS_SEC_BSS STATIC UINT64 cpupIntTimeStart[LOSCFG_KERNEL_CORE_NUM]

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

cpupMaxNum

LITE_OS_SEC_BSS STATIC UINT32 cpupMaxNum

在文件 los_cpup.c 第 126 行定义.

cpupStartCycles

LITE_OS_SEC_BSS STATIC UINT64 cpupStartCycles = 0

记录

在文件 los_cpup.c 第 130 行定义.

cpupSwtmrID

LITE_OS_SEC_BSS STATIC UINT16 cpupSwtmrID

监测CPU使用情况定时器s

在文件 los_cpup.c 第 123 行定义.

g_irqCpup

LITE_OS_SEC_BSS OsIrqCpupCB* g_irqCpup = NULL

在文件 los_cpup.c 第 125 行定义.

runningTasks

LITE_OS_SEC_BSS STATIC UINT32 runningTasks[LOSCFG_KERNEL_CORE_NUM]

在文件 los_cpup.c 第 129 行定义.

timeInIrqSwitch

LITE_OS_SEC_BSS UINT64 timeInIrqSwitch[LOSCFG_KERNEL_CORE_NUM]

在文件 los_cpup.c 第 132 行定义.