1 /*
2 * Copyright (c) 2022-2022 Huawei Device Co., Ltd. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification,
5 * are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific prior written
16 * permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "los_sched_pri.h"
32 #include "los_process_pri.h"
33
34 STATIC VOID IdleDequeue(SchedRunqueue *rq, LosTaskCB *taskCB);
35 STATIC VOID IdleEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB);
36 STATIC UINT32 IdleWait(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 ticks);
37 STATIC VOID IdleWake(LosTaskCB *resumedTask);
38 STATIC UINT32 IdleSchedParamGet(const LosTaskCB *taskCB, SchedParam *param);
39 STATIC VOID IdleYield(LosTaskCB *runTask);
40 STATIC VOID IdleStartToRun(SchedRunqueue *rq, LosTaskCB *taskCB);
41 STATIC UINT32 IdleResume(LosTaskCB *taskCB, BOOL *needSched);
42 STATIC UINT64 IdleTimeSliceGet(const LosTaskCB *taskCB);
43 STATIC VOID IdleTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime);
44 STATIC INT32 IdleParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2);
45 STATIC VOID IdlePriorityInheritance(LosTaskCB *owner, const SchedParam *param);
46 STATIC VOID IdlePriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param);
47
48 const STATIC SchedOps g_idleOps = {
49 .dequeue = IdleDequeue,
50 .enqueue = IdleEnqueue,
51 .wait = IdleWait,
52 .wake = IdleWake,
53 .schedParamModify = NULL,
54 .schedParamGet = IdleSchedParamGet,
55 .delay = NULL,
56 .yield = IdleYield,
57 .start = IdleStartToRun,
58 .exit = NULL,
59 .suspend = NULL,
60 .resume = IdleResume,
61 .deadlineGet = IdleTimeSliceGet,
62 .timeSliceUpdate = IdleTimeSliceUpdate,
63 .schedParamCompare = IdleParamCompare,
64 .priorityInheritance = IdlePriorityInheritance,
65 .priorityRestore = IdlePriorityRestore,
66 };
67
IdleTimeSliceUpdate(SchedRunqueue * rq,LosTaskCB * taskCB,UINT64 currTime)68 STATIC VOID IdleTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime)
69 {
70 (VOID)rq;
71
72 taskCB->startTime = currTime;
73 }
74
IdleTimeSliceGet(const LosTaskCB * taskCB)75 STATIC UINT64 IdleTimeSliceGet(const LosTaskCB *taskCB)
76 {
77 (VOID)taskCB;
78 return (OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION);
79 }
80
IdleEnqueue(SchedRunqueue * rq,LosTaskCB * taskCB)81 STATIC VOID IdleEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB)
82 {
83 (VOID)rq;
84
85 taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED;
86 taskCB->taskStatus |= OS_TASK_STATUS_READY;
87 }
88
IdleDequeue(SchedRunqueue * rq,LosTaskCB * taskCB)89 STATIC VOID IdleDequeue(SchedRunqueue *rq, LosTaskCB *taskCB)
90 {
91 (VOID)rq;
92
93 taskCB->taskStatus &= ~OS_TASK_STATUS_READY;
94 }
95
IdleStartToRun(SchedRunqueue * rq,LosTaskCB * taskCB)96 STATIC VOID IdleStartToRun(SchedRunqueue *rq, LosTaskCB *taskCB)
97 {
98 IdleDequeue(rq, taskCB);
99 }
100
IdleYield(LosTaskCB * runTask)101 STATIC VOID IdleYield(LosTaskCB *runTask)
102 {
103 (VOID)runTask;
104 return;
105 }
106
IdleWait(LosTaskCB * runTask,LOS_DL_LIST * list,UINT32 ticks)107 STATIC UINT32 IdleWait(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 ticks)
108 {
109 (VOID)runTask;
110 (VOID)list;
111 (VOID)ticks;
112
113 return LOS_NOK;
114 }
115
IdleWake(LosTaskCB * resumedTask)116 STATIC VOID IdleWake(LosTaskCB *resumedTask)
117 {
118 LOS_ListDelete(&resumedTask->pendList);
119 resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING;
120
121 if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) {
122 OsSchedTimeoutQueueDelete(resumedTask);
123 resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME;
124 }
125
126 if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) {
127 #ifdef LOSCFG_SCHED_DEBUG
128 resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime;
129 resumedTask->schedStat.pendCount++;
130 #endif
131 resumedTask->ops->enqueue(OsSchedRunqueue(), resumedTask);
132 }
133 }
134
IdleResume(LosTaskCB * taskCB,BOOL * needSched)135 STATIC UINT32 IdleResume(LosTaskCB *taskCB, BOOL *needSched)
136 {
137 *needSched = FALSE;
138
139 taskCB->taskStatus &= ~OS_TASK_STATUS_SUSPENDED;
140 if (!OsTaskIsBlocked(taskCB)) {
141 taskCB->ops->enqueue(OsSchedRunqueue(), taskCB);
142 *needSched = TRUE;
143 }
144 return LOS_OK;
145 }
146
IdleSchedParamGet(const LosTaskCB * taskCB,SchedParam * param)147 STATIC UINT32 IdleSchedParamGet(const LosTaskCB *taskCB, SchedParam *param)
148 {
149 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
150 param->policy = sched->policy;
151 param->basePrio = sched->basePrio;
152 param->priority = sched->priority;
153 param->timeSlice = 0;
154 return LOS_OK;
155 }
156
IdleParamCompare(const SchedPolicy * sp1,const SchedPolicy * sp2)157 STATIC INT32 IdleParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2)
158 {
159 return 0;
160 }
161
IdlePriorityInheritance(LosTaskCB * owner,const SchedParam * param)162 STATIC VOID IdlePriorityInheritance(LosTaskCB *owner, const SchedParam *param)
163 {
164 (VOID)owner;
165 (VOID)param;
166 return;
167 }
168
IdlePriorityRestore(LosTaskCB * owner,const LOS_DL_LIST * list,const SchedParam * param)169 STATIC VOID IdlePriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param)
170 {
171 (VOID)owner;
172 (VOID)list;
173 (VOID)param;
174 return;
175 }
176
IdleTaskSchedParamInit(LosTaskCB * taskCB)177 VOID IdleTaskSchedParamInit(LosTaskCB *taskCB)
178 {
179 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
180 sched->policy = LOS_SCHED_IDLE;
181 sched->basePrio = OS_PROCESS_PRIORITY_LOWEST;
182 sched->priority = OS_TASK_PRIORITY_LOWEST;
183 sched->initTimeSlice = 0;
184 taskCB->timeSlice = sched->initTimeSlice;
185 taskCB->taskStatus = OS_TASK_STATUS_SUSPENDED;
186 taskCB->ops = &g_idleOps;
187 }
188