los_sched.c 文件参考

浏览源代码.

函数
STATIC INLINE VOID	SchedNextExpireTimeSet (UINT32 responseID, UINT64 taskEndTime, UINT32 oldResponseID)
VOID	OsSchedExpireTimeUpdate (VOID)
STATIC INLINE VOID	SchedTimeoutTaskWake (SchedRunqueue *rq, UINT64 currTime, LosTaskCB *taskCB, BOOL *needSched)
STATIC INLINE BOOL	SchedTimeoutQueueScan (SchedRunqueue *rq)
VOID	OsSchedTick (VOID)
VOID	OsSchedResponseTimeReset (UINT64 responseTime)
VOID	OsSchedRunqueueInit (VOID)
VOID	OsSchedRunqueueIdleInit (UINT32 idleTaskID)
UINT32	OsSchedInit (VOID)
INT32	OsSchedParamCompare (const LosTaskCB *task1, const LosTaskCB *task2)
UINT32	OsSchedParamInit (LosTaskCB *taskCB, UINT16 policy, const SchedParam *parentParam, const TSK_INIT_PARAM_S *param)
VOID	OsSchedProcessDefaultSchedParamGet (UINT16 policy, SchedParam *param)
STATIC LosTaskCB *	TopTaskGet (SchedRunqueue *rq)
VOID	OsSchedStart (VOID)
VOID	OsSchedToUserReleaseLock (VOID)
STATIC VOID	TaskStackCheck (LosTaskCB *runTask, LosTaskCB *newTask)
STATIC INLINE VOID	SchedSwitchCheck (LosTaskCB *runTask, LosTaskCB *newTask)
STATIC VOID	SchedTaskSwitch (SchedRunqueue *rq, LosTaskCB *runTask, LosTaskCB *newTask)
VOID	OsSchedIrqEndCheckNeedSched (VOID)
VOID	OsSchedResched (VOID)
VOID	LOS_Schedule (VOID)
	Trigger active task scheduling. 更多...
STATIC INLINE LOS_DL_LIST *	SchedLockPendFindPosSub (const LosTaskCB *runTask, const LOS_DL_LIST *lockList)
LOS_DL_LIST *	OsSchedLockPendFindPos (const LosTaskCB *runTask, LOS_DL_LIST *lockList)

变量
SchedRunqueue	g_schedRunqueue [LOSCFG_KERNEL_CORE_NUM]

函数说明

OsSchedExpireTimeUpdate()

VOID OsSchedExpireTimeUpdate

(

VOID

)

在文件 los_sched.c 第 88 行定义.

{
    UINT32 intSave;
    if (!OS_SCHEDULER_ACTIVE || OS_INT_ACTIVE) {
        OsSchedRunqueuePendingSet();
        return;
    }
 
    LosTaskCB *runTask = OsCurrTaskGet();
    SCHEDULER_LOCK(intSave);
    UINT64 deadline = runTask->ops->deadlineGet(runTask);
    SCHEDULER_UNLOCK(intSave);
    SchedNextExpireTimeSet(runTask->taskID, deadline, runTask->taskID);
}

函数调用图:

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

OsSchedInit()

UINT32 OsSchedInit

(

VOID

)

在文件 los_sched.c 第 213 行定义.

{
    for (UINT16 cpuId = 0; cpuId < LOSCFG_KERNEL_CORE_NUM; cpuId++) {
        HPFSchedPolicyInit(OsSchedRunqueueByID(cpuId));
    }
 
#ifdef LOSCFG_SCHED_TICK_DEBUG
    UINT32 ret = OsSchedDebugInit();
    if (ret != LOS_OK) {
        return ret;
    }
#endif
    return LOS_OK;
}

函数调用图:

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

OsSchedIrqEndCheckNeedSched()

VOID OsSchedIrqEndCheckNeedSched

(

VOID

)

在文件 los_sched.c 第 420 行定义.

{
    SchedRunqueue *rq = OsSchedRunqueue();
    LosTaskCB *runTask = OsCurrTaskGet();
 
    runTask->ops->timeSliceUpdate(rq, runTask, OsGetCurrSchedTimeCycle());
 
    if (OsPreemptable() && (rq->schedFlag & INT_PEND_RESCH)) {
        rq->schedFlag &= ~INT_PEND_RESCH;
 
        LOS_SpinLock(&g_taskSpin);
 
        runTask->ops->enqueue(rq, runTask);
 
        LosTaskCB *newTask = TopTaskGet(rq);
        if (runTask != newTask) {
            SchedTaskSwitch(rq, runTask, newTask);
            LOS_SpinUnlock(&g_taskSpin);
            return;
        }
 
        LOS_SpinUnlock(&g_taskSpin);
    }
 
    if (rq->schedFlag & INT_PEND_TICK) {
        OsSchedExpireTimeUpdate();
    }
}

函数调用图:

OsSchedLockPendFindPos()

LOS_DL_LIST * OsSchedLockPendFindPos	(	const LosTaskCB *	runTask,
		LOS_DL_LIST *	lockList
	)

在文件 los_sched.c 第 519 行定义.

{
    if (LOS_ListEmpty(lockList)) {
        return lockList;
    }
 
    LosTaskCB *pendedTask1 = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(lockList));
    INT32 ret = OsSchedParamCompare(pendedTask1, runTask);
    if (ret > 0) {
        return lockList->pstNext;
    }
 
    LosTaskCB *pendedTask2 = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_LAST(lockList));
    ret = OsSchedParamCompare(pendedTask2, runTask);
    if (ret <= 0) {
        return lockList;
    }
 
    return SchedLockPendFindPosSub(runTask, lockList);
}

函数调用图:

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

OsSchedParamCompare()

INT32 OsSchedParamCompare	(	const LosTaskCB *	task1,
		const LosTaskCB *	task2
	)

在文件 los_sched.c 第 233 行定义.

{
    SchedHPF *rp1 = (SchedHPF *)&task1->sp;
    SchedHPF *rp2 = (SchedHPF *)&task2->sp;
 
    if (rp1->policy == rp2->policy) {
        return task1->ops->schedParamCompare(&task1->sp, &task2->sp);
    }
 
    if (rp1->policy == LOS_SCHED_IDLE) {
        return 1;
    } else if (rp2->policy == LOS_SCHED_IDLE) {
        return -1;
    }
    return 0;
}

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

OsSchedParamInit()

UINT32 OsSchedParamInit	(	LosTaskCB *	taskCB,
		UINT16	policy,
		const SchedParam *	parentParam,
		const TSK_INIT_PARAM_S *	param
	)

在文件 los_sched.c 第 250 行定义.

{
    switch (policy) {
        case LOS_SCHED_FIFO:
        case LOS_SCHED_RR:
            HPFTaskSchedParamInit(taskCB, policy, parentParam, param);
            break;
        case LOS_SCHED_IDLE:
            IdleTaskSchedParamInit(taskCB);
            break;
        default:
            return LOS_NOK;
    }
 
    return LOS_OK;
}

函数调用图:

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

OsSchedProcessDefaultSchedParamGet()

VOID OsSchedProcessDefaultSchedParamGet	(	UINT16	policy,
		SchedParam *	param
	)

在文件 los_sched.c 第 267 行定义.

{
    switch (policy) {
        case LOS_SCHED_FIFO:
        case LOS_SCHED_RR:
            HPFProcessDefaultSchedParamGet(param);
            break;
        case LOS_SCHED_IDLE:
        default:
            PRINT_ERR("Invalid process-level scheduling policy, %u\n", policy);
            break;
    }
    return;
}

函数调用图:

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

OsSchedResched()

VOID OsSchedResched

(

VOID

)

在文件 los_sched.c 第 449 行定义.

{
    LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));
    SchedRunqueue *rq = OsSchedRunqueue();
#ifdef LOSCFG_KERNEL_SMP
    LOS_ASSERT(rq->taskLockCnt == 1);
#else
    LOS_ASSERT(rq->taskLockCnt == 0);
#endif
 
    rq->schedFlag &= ~INT_PEND_RESCH;
    LosTaskCB *runTask = OsCurrTaskGet();
    LosTaskCB *newTask = TopTaskGet(rq);
    if (runTask == newTask) {
        return;
    }
 
    SchedTaskSwitch(rq, runTask, newTask);
}

函数调用图:

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

OsSchedResponseTimeReset()

VOID OsSchedResponseTimeReset

(

UINT64

responseTime

)

在文件 los_sched.c 第 189 行定义.

{
    OsSchedRunqueue()->responseTime = responseTime;
}

函数调用图:

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

OsSchedRunqueueIdleInit()

VOID OsSchedRunqueueIdleInit

(

UINT32

idleTaskID

)

在文件 los_sched.c 第 207 行定义.

{
    SchedRunqueue *rq = OsSchedRunqueue();
    rq->idleTaskID = idleTaskID;
}

函数调用图:

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

OsSchedRunqueueInit()

VOID OsSchedRunqueueInit

(

VOID

)

在文件 los_sched.c 第 194 行定义.

{
    if (ArchCurrCpuid() != 0) {
        return;
    }
 
    for (UINT16 index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
        SchedRunqueue *rq = OsSchedRunqueueByID(index);
        OsSortLinkInit(&rq->timeoutQueue);
        rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
    }
}

函数调用图:

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

OsSchedStart()

VOID OsSchedStart

(

VOID

)

在文件 los_sched.c 第 294 行定义.

{
    UINT32 cpuid = ArchCurrCpuid();
    UINT32 intSave;
 
    PRINTK("cpu %d entering scheduler\n", cpuid);
 
    SCHEDULER_LOCK(intSave);
 
    OsTickStart();
 
    SchedRunqueue *rq = OsSchedRunqueue();
    LosTaskCB *newTask = TopTaskGet(rq);
    newTask->taskStatus |= OS_TASK_STATUS_RUNNING;
 
#ifdef LOSCFG_KERNEL_SMP
    /* 注意：需要设置当前cpu，以防第一个任务删除失败，因为这个标志与真实的当前cpu不匹配
     * attention: current cpu needs to be set, in case first task deletion
     * may fail because this flag mismatch with the real current cpu.
     */
    newTask->currCpu = cpuid;//记录本次运行交给哪个CPU核
#endif
 
    OsCurrTaskSet((VOID *)newTask);//设置新任务,背后的逻辑是将新任务的地址交给硬件保存
 
    newTask->startTime = OsGetCurrSchedTimeCycle();
 
    OsSwtmrResponseTimeReset(newTask->startTime);
 
    /* System start schedule */
    OS_SCHEDULER_SET(cpuid);
 
    rq->responseID = OS_INVALID;
    UINT64 deadline = newTask->ops->deadlineGet(newTask);
    SchedNextExpireTimeSet(newTask->taskID, deadline, OS_INVALID);
    OsTaskContextLoad(newTask);
}

函数调用图:

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

OsSchedTick()

VOID OsSchedTick

(

VOID

)

在文件 los_sched.c 第 175 行定义.

{
    SchedRunqueue *rq = OsSchedRunqueue();
 
    if (rq->responseID == OS_INVALID_VALUE) {
        if (SchedTimeoutQueueScan(rq)) {
            LOS_MpSchedule(OS_MP_CPU_ALL);
            rq->schedFlag |= INT_PEND_RESCH;
        }
    }
    rq->schedFlag |= INT_PEND_TICK;
    rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
}

函数调用图:

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

OsSchedToUserReleaseLock()

VOID OsSchedToUserReleaseLock

(

VOID

)

在文件 los_sched.c 第 333 行定义.

{
    /* The scheduling lock needs to be released before returning to user mode */
    LOCKDEP_CHECK_OUT(&g_taskSpin);
    ArchSpinUnlock(&g_taskSpin.rawLock);
 
    OsSchedUnlock();
}

函数调用图:

SchedLockPendFindPosSub()

STATIC INLINE LOS_DL_LIST * SchedLockPendFindPosSub	(	const LosTaskCB *	runTask,
		const LOS_DL_LIST *	lockList
	)

在文件 los_sched.c 第 502 行定义.

{
    LosTaskCB *pendedTask = NULL;
 
    LOS_DL_LIST_FOR_EACH_ENTRY(pendedTask, lockList, LosTaskCB, pendList) {
        INT32 ret = OsSchedParamCompare(pendedTask, runTask);
        if (ret < 0) {
            continue;
        } else if (ret > 0) {
            return &pendedTask->pendList;
        } else {
            return pendedTask->pendList.pstNext;
        }
    }
    return NULL;
}

函数调用图:

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

SchedNextExpireTimeSet()

STATIC INLINE VOID SchedNextExpireTimeSet	(	UINT32	responseID,
		UINT64	taskEndTime,
		UINT32	oldResponseID
	)

在文件 los_sched.c 第 51 行定义.

{
    SchedRunqueue *rq = OsSchedRunqueue();
    BOOL isTimeSlice = FALSE;
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    UINT64 nextExpireTime = OsGetSortLinkNextExpireTime(&rq->timeoutQueue, currTime, OS_TICK_RESPONSE_PRECISION);
 
    rq->schedFlag &= ~INT_PEND_TICK;
    if (rq->responseID == oldResponseID) {
        /* This time has expired, and the next time the theory has expired is infinite */
        rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
    }
 
    /* The current thread's time slice has been consumed, but the current system lock task cannot
     * trigger the schedule to release the CPU
     */
    if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) {
        nextExpireTime = taskEndTime;
        isTimeSlice = TRUE;
    }
 
    if ((rq->responseTime <= nextExpireTime) ||
        ((rq->responseTime - nextExpireTime) < OS_TICK_RESPONSE_PRECISION)) {
        return;
    }
 
    if (isTimeSlice) {
        /* The expiration time of the current system is the thread's slice expiration time */
        rq->responseID = responseID;
    } else {
        rq->responseID = OS_INVALID_VALUE;
    }
 
    UINT64 nextResponseTime = nextExpireTime - currTime;
    rq->responseTime = currTime + HalClockTickTimerReload(nextResponseTime);
}

函数调用图:

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

SchedSwitchCheck()

STATIC INLINE VOID SchedSwitchCheck	(	LosTaskCB *	runTask,
		LosTaskCB *	newTask
	)

在文件 los_sched.c 第 358 行定义.

{
#ifdef LOSCFG_BASE_CORE_TSK_MONITOR
    TaskStackCheck(runTask, newTask);
#endif /* LOSCFG_BASE_CORE_TSK_MONITOR */
    OsHookCall(LOS_HOOK_TYPE_TASK_SWITCHEDIN, newTask, runTask);
}

函数调用图:

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

SchedTaskSwitch()

STATIC VOID SchedTaskSwitch	(	SchedRunqueue *	rq,
		LosTaskCB *	runTask,
		LosTaskCB *	newTask
	)

在文件 los_sched.c 第 366 行定义.

{
    SchedSwitchCheck(runTask, newTask);
 
    runTask->taskStatus &= ~OS_TASK_STATUS_RUNNING;
    newTask->taskStatus |= OS_TASK_STATUS_RUNNING;
 
#ifdef LOSCFG_KERNEL_SMP
    /* mask new running task's owner processor */
    runTask->currCpu = OS_TASK_INVALID_CPUID;
    newTask->currCpu = ArchCurrCpuid();
#endif
 
    OsCurrTaskSet((VOID *)newTask);
#ifdef LOSCFG_KERNEL_VM
    if (newTask->archMmu != runTask->archMmu) {
        LOS_ArchMmuContextSwitch((LosArchMmu *)newTask->archMmu);
    }
#endif
 
#ifdef LOSCFG_KERNEL_CPUP
    OsCpupCycleEndStart(runTask->taskID, newTask->taskID);
#endif
 
#ifdef LOSCFG_SCHED_DEBUG
    UINT64 waitStartTime = newTask->startTime;
#endif
    if (runTask->taskStatus & OS_TASK_STATUS_READY) {
        /* When a thread enters the ready queue, its slice of time is updated */
        newTask->startTime = runTask->startTime;
    } else {
        /* The currently running task is blocked */
        newTask->startTime = OsGetCurrSchedTimeCycle();
        /* The task is in a blocking state and needs to update its time slice before pend */
        runTask->ops->timeSliceUpdate(rq, runTask, newTask->startTime);
 
        if (runTask->taskStatus & (OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY)) {
            OsSchedTimeoutQueueAdd(runTask, runTask->startTime + runTask->waitTime);
        }
    }
 
    UINT64 deadline = newTask->ops->deadlineGet(newTask);
    SchedNextExpireTimeSet(newTask->taskID, deadline, runTask->taskID);
 
#ifdef LOSCFG_SCHED_DEBUG
    newTask->schedStat.waitSchedTime += newTask->startTime - waitStartTime;
    newTask->schedStat.waitSchedCount++;
    runTask->schedStat.runTime = runTask->schedStat.allRuntime;
    runTask->schedStat.switchCount++;
#endif
    /* do the task context switch */
    OsTaskSchedule(newTask, runTask);
}

函数调用图:

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

SchedTimeoutQueueScan()

STATIC INLINE BOOL SchedTimeoutQueueScan

(

SchedRunqueue *

rq

)

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

{
    BOOL needSched = FALSE;
    SortLinkAttribute *timeoutQueue = &rq->timeoutQueue;
    LOS_DL_LIST *listObject = &timeoutQueue->sortLink;
    /*
     * When task is pended with timeout, the task block is on the timeout sortlink
     * (per cpu) and ipc(mutex,sem and etc.)'s block at the same time, it can be waken
     * up by either timeout or corresponding ipc it's waiting.
     *
     * Now synchronize sortlink procedure is used, therefore the whole task scan needs
     * to be protected, preventing another core from doing sortlink deletion at same time.
     */
    LOS_SpinLock(&timeoutQueue->spinLock);
 
    if (LOS_ListEmpty(listObject)) {
        LOS_SpinUnlock(&timeoutQueue->spinLock);
        return needSched;
    }
 
    SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
    UINT64 currTime = OsGetCurrSchedTimeCycle();
    while (sortList->responseTime <= currTime) {
        LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(sortList, LosTaskCB, sortList);
        OsDeleteNodeSortLink(timeoutQueue, &taskCB->sortList);
        LOS_SpinUnlock(&timeoutQueue->spinLock);
 
        SchedTimeoutTaskWake(rq, currTime, taskCB, &needSched);
 
        LOS_SpinLock(&timeoutQueue->spinLock);
        if (LOS_ListEmpty(listObject)) {
            break;
        }
 
        sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
    }
 
    LOS_SpinUnlock(&timeoutQueue->spinLock);
 
    return needSched;
}

函数调用图:

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

SchedTimeoutTaskWake()

STATIC INLINE VOID SchedTimeoutTaskWake	(	SchedRunqueue *	rq,
		UINT64	currTime,
		LosTaskCB *	taskCB,
		BOOL *	needSched
	)

在文件 los_sched.c 第 103 行定义.

{
#ifndef LOSCFG_SCHED_DEBUG
    (VOID)currTime;
#endif
 
    LOS_SpinLock(&g_taskSpin);
    UINT16 tempStatus = taskCB->taskStatus;
    if (tempStatus & (OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY)) {
        taskCB->taskStatus &= ~(OS_TASK_STATUS_PENDING | OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY);
        if (tempStatus & OS_TASK_STATUS_PENDING) {
            taskCB->taskStatus |= OS_TASK_STATUS_TIMEOUT;
            LOS_ListDelete(&taskCB->pendList);
            taskCB->taskMux = NULL;
            OsTaskWakeClearPendMask(taskCB);
        }
 
        if (!(tempStatus & OS_TASK_STATUS_SUSPENDED)) {
#ifdef LOSCFG_SCHED_DEBUG
            taskCB->schedStat.pendTime += currTime - taskCB->startTime;
            taskCB->schedStat.pendCount++;
#endif
            taskCB->ops->enqueue(rq, taskCB);
            *needSched = TRUE;
        }
    }
 
    LOS_SpinUnlock(&g_taskSpin);
}

函数调用图:

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

TaskStackCheck()

STATIC VOID TaskStackCheck	(	LosTaskCB *	runTask,
		LosTaskCB *	newTask
	)

在文件 los_sched.c 第 344 行定义.

{
    if (!OS_STACK_MAGIC_CHECK(runTask->topOfStack)) {
        LOS_Panic("CURRENT task ID: %s:%d stack overflow!\n", runTask->taskName, runTask->taskID);
    }
 
    if (((UINTPTR)(newTask->stackPointer) <= newTask->topOfStack) ||
        ((UINTPTR)(newTask->stackPointer) > (newTask->topOfStack + newTask->stackSize))) {
        LOS_Panic("HIGHEST task ID: %s:%u SP error! StackPointer: %p TopOfStack: %p\n",
                  newTask->taskName, newTask->taskID, newTask->stackPointer, newTask->topOfStack);
    }
}

函数调用图:

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

TopTaskGet()

STATIC LosTaskCB * TopTaskGet

(

SchedRunqueue *

rq

)

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

{
    LosTaskCB *newTask = HPFRunqueueTopTaskGet(rq->hpfRunqueue);
 
    if (newTask == NULL) {
        newTask = OS_TCB_FROM_TID(rq->idleTaskID);
    }
 
    newTask->ops->start(rq, newTask);
    return newTask;
}

函数调用图:

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

变量说明

g_schedRunqueue

SchedRunqueue g_schedRunqueue[LOSCFG_KERNEL_CORE_NUM]

在文件 los_sched.c 第 49 行定义.