更新日期: 2022/06/01 来源: https://gitee.com/weharmony/kernel_liteos_a_note
los_priority.c
浏览该文件的文档.
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_task_pri.h"
33#include "los_process_pri.h"
34#include "los_hook.h"
35#include "los_tick_pri.h"
36#include "los_mp.h"
37
38#define OS_SCHED_FIFO_TIMEOUT 0x7FFFFFFF
39#define PRIQUEUE_PRIOR0_BIT 0x80000000U
40#define OS_SCHED_TIME_SLICES_MIN ((5000 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 5ms */
41#define OS_SCHED_TIME_SLICES_MAX ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE)
42#define OS_SCHED_TIME_SLICES_DIFF (OS_SCHED_TIME_SLICES_MAX - OS_SCHED_TIME_SLICES_MIN)
43#define OS_SCHED_READY_MAX 30
44#define OS_TIME_SLICE_MIN (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */
45
46//基于优先数调度算法 Highest-Priority-First (HPF)
47
49
50STATIC VOID HPFDequeue(SchedRunqueue *rq, LosTaskCB *taskCB);
51STATIC VOID HPFEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB);
52STATIC UINT32 HPFWait(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 ticks);
53STATIC VOID HPFWake(LosTaskCB *resumedTask);
54STATIC BOOL HPFSchedParamModify(LosTaskCB *taskCB, const SchedParam *param);
55STATIC UINT32 HPFSchedParamGet(const LosTaskCB *taskCB, SchedParam *param);
56STATIC UINT32 HPFDelay(LosTaskCB *runTask, UINT64 waitTime);
57STATIC VOID HPFYield(LosTaskCB *runTask);
58STATIC VOID HPFStartToRun(SchedRunqueue *rq, LosTaskCB *taskCB);
59STATIC VOID HPFExit(LosTaskCB *taskCB);
60STATIC UINT32 HPFSuspend(LosTaskCB *taskCB);
61STATIC UINT32 HPFResume(LosTaskCB *taskCB, BOOL *needSched);
62STATIC UINT64 HPFTimeSliceGet(const LosTaskCB *taskCB);
63STATIC VOID HPFTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime);
64STATIC INT32 HPFParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2);
65STATIC VOID HPFPriorityInheritance(LosTaskCB *owner, const SchedParam *param);
66STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param);
67//优先级调度算法操作
68const STATIC SchedOps g_priorityOps = {
70 .enqueue = HPFEnqueue,
71 .wait = HPFWait,
72 .wake = HPFWake,
73 .schedParamModify = HPFSchedParamModify,
74 .schedParamGet = HPFSchedParamGet,
75 .delay = HPFDelay,
76 .yield = HPFYield,
77 .start = HPFStartToRun,
78 .exit = HPFExit,
79 .suspend = HPFSuspend,
80 .resume = HPFResume,
81 .deadlineGet = HPFTimeSliceGet,
82 .timeSliceUpdate = HPFTimeSliceUpdate,
83 .schedParamCompare = HPFParamCompare,
84 .priorityInheritance = HPFPriorityInheritance,
85 .priorityRestore = HPFPriorityRestore,
86};
87
88STATIC VOID HPFTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime)
89{
90 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
91 LOS_ASSERT(currTime >= taskCB->startTime);
92
93 INT32 incTime = (currTime - taskCB->startTime - taskCB->irqUsedTime);
94
95 LOS_ASSERT(incTime >= 0);
96
97 if (sched->policy == LOS_SCHED_RR) {
98 taskCB->timeSlice -= incTime;
99#ifdef LOSCFG_SCHED_DEBUG
100 taskCB->schedStat.timeSliceRealTime += incTime;
101#endif
102 }
103 taskCB->irqUsedTime = 0;
104 taskCB->startTime = currTime;
105 if (taskCB->timeSlice <= OS_TIME_SLICE_MIN) {
107 }
108
109#ifdef LOSCFG_SCHED_DEBUG
110 taskCB->schedStat.allRuntime += incTime;
111#endif
112}
113
114STATIC UINT64 HPFTimeSliceGet(const LosTaskCB *taskCB)
115{
116 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
117 INT32 timeSlice = taskCB->timeSlice;
118
119 timeSlice = (timeSlice <= OS_TIME_SLICE_MIN) ? sched->initTimeSlice : timeSlice;
120 return (taskCB->startTime + timeSlice);
121}
122
123STATIC INLINE UINT32 TimeSliceCalculate(HPFRunqueue *rq, UINT16 basePrio, UINT16 priority)
124{
125 UINT32 time;
126 UINT32 readyTasks;
127
128 HPFQueue *queueList = &rq->queueList[basePrio];
129 readyTasks = queueList->readyTasks[priority];
130 if (readyTasks > OS_SCHED_READY_MAX) {
131 return OS_SCHED_TIME_SLICES_MIN;
132 }
133 time = ((OS_SCHED_READY_MAX - readyTasks) * OS_SCHED_TIME_SLICES_DIFF) / OS_SCHED_READY_MAX;
134 return (time + OS_SCHED_TIME_SLICES_MIN);
135}
136
137STATIC INLINE VOID PriQueHeadInsert(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
138{
139 HPFQueue *queueList = &rq->queueList[basePrio];
140 LOS_DL_LIST *priQueList = &queueList->priQueList[0];
141 UINT32 *bitmap = &queueList->queueBitmap;
142
143 /*
144 * Task control blocks are inited as zero. And when task is deleted,
145 * and at the same time would be deleted from priority queue or
146 * other lists, task pend node will restored as zero.
147 */
148 LOS_ASSERT(priQue->pstNext == NULL);
149
150 if (*bitmap == 0) {
151 rq->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> basePrio;
152 }
153
154 if (LOS_ListEmpty(&priQueList[priority])) {
155 *bitmap |= PRIQUEUE_PRIOR0_BIT >> priority;
156 }
157
158 LOS_ListHeadInsert(&priQueList[priority], priQue);
159 queueList->readyTasks[priority]++;
160}
161
162STATIC INLINE VOID PriQueTailInsert(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
163{
164 HPFQueue *queueList = &rq->queueList[basePrio];
165 LOS_DL_LIST *priQueList = &queueList->priQueList[0];
166 UINT32 *bitmap = &queueList->queueBitmap;
167
168 /*
169 * Task control blocks are inited as zero. And when task is deleted,
170 * and at the same time would be deleted from priority queue or
171 * other lists, task pend node will restored as zero.
172 */
173 LOS_ASSERT(priQue->pstNext == NULL);
174
175 if (*bitmap == 0) {
176 rq->queueBitmap |= PRIQUEUE_PRIOR0_BIT >> basePrio;
177 }
178
179 if (LOS_ListEmpty(&priQueList[priority])) {
180 *bitmap |= PRIQUEUE_PRIOR0_BIT >> priority;
181 }
182
183 LOS_ListTailInsert(&priQueList[priority], priQue);
184 queueList->readyTasks[priority]++;
185}
186
187STATIC INLINE VOID PriQueDelete(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
188{
189 HPFQueue *queueList = &rq->queueList[basePrio];
190 LOS_DL_LIST *priQueList = &queueList->priQueList[0];
191 UINT32 *bitmap = &queueList->queueBitmap;
192
193 LOS_ListDelete(priQue);
194 queueList->readyTasks[priority]--;
195 if (LOS_ListEmpty(&priQueList[priority])) {
196 *bitmap &= ~(PRIQUEUE_PRIOR0_BIT >> priority);
197 }
198
199 if (*bitmap == 0) {
200 rq->queueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> basePrio);
201 }
202}
203
204STATIC INLINE VOID PriQueInsert(HPFRunqueue *rq, LosTaskCB *taskCB)
205{
206 LOS_ASSERT(!(taskCB->taskStatus & OS_TASK_STATUS_READY));
207 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
208
209 switch (sched->policy) {
210 case LOS_SCHED_RR: {
211 if (taskCB->timeSlice > OS_TIME_SLICE_MIN) {
212 PriQueHeadInsert(rq, sched->basePrio, &taskCB->pendList, sched->priority);
213 } else {
214 sched->initTimeSlice = TimeSliceCalculate(rq, sched->basePrio, sched->priority);
215 taskCB->timeSlice = sched->initTimeSlice;
216 PriQueTailInsert(rq, sched->basePrio, &taskCB->pendList, sched->priority);
217#ifdef LOSCFG_SCHED_DEBUG
219 taskCB->schedStat.timeSliceCount++;
220#endif
221 }
222 break;
223 }
224 case LOS_SCHED_FIFO: {
225 /* The time slice of FIFO is always greater than 0 unless the yield is called */
226 if ((taskCB->timeSlice > OS_TIME_SLICE_MIN) && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
227 PriQueHeadInsert(rq, sched->basePrio, &taskCB->pendList, sched->priority);
228 } else {
229 sched->initTimeSlice = OS_SCHED_FIFO_TIMEOUT;
230 taskCB->timeSlice = sched->initTimeSlice;
231 PriQueTailInsert(rq, sched->basePrio, &taskCB->pendList, sched->priority);
232 }
233 break;
234 }
235 default:
236 LOS_ASSERT(0);
237 break;
238 }
239
240 taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED;
241 taskCB->taskStatus |= OS_TASK_STATUS_READY;
242}
243//入就绪队列
244STATIC VOID HPFEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB)
245{
246#ifdef LOSCFG_SCHED_DEBUG
247 if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
249 }
250#endif
251 PriQueInsert(rq->hpfRunqueue, taskCB);
252}
253//出就绪队列
254STATIC VOID HPFDequeue(SchedRunqueue *rq, LosTaskCB *taskCB)
255{
256 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
257
258 if (taskCB->taskStatus & OS_TASK_STATUS_READY) {//是否有就绪状态
259 PriQueDelete(rq->hpfRunqueue, sched->basePrio, &taskCB->pendList, sched->priority);
260 taskCB->taskStatus &= ~OS_TASK_STATUS_READY;//更新成非就绪状态
261 }
262}
263
264STATIC VOID HPFStartToRun(SchedRunqueue *rq, LosTaskCB *taskCB)
265{
266 HPFDequeue(rq, taskCB);
267}
268
269STATIC VOID HPFExit(LosTaskCB *taskCB)
270{
271 if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
272 HPFDequeue(OsSchedRunqueue(), taskCB);
273 } else if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) {
274 LOS_ListDelete(&taskCB->pendList);
275 taskCB->taskStatus &= ~OS_TASK_STATUS_PENDING;
276 }
277
278 if (taskCB->taskStatus & (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)) {
280 taskCB->taskStatus &= ~(OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME);
281 }
282}
283
284STATIC VOID HPFYield(LosTaskCB *runTask)
285{
287 runTask->timeSlice = 0;
288
290 HPFEnqueue(rq, runTask);
292}
293
294STATIC UINT32 HPFDelay(LosTaskCB *runTask, UINT64 waitTime)
295{
296 runTask->taskStatus |= OS_TASK_STATUS_DELAY;
297 runTask->waitTime = waitTime;
298
300 return LOS_OK;
301}
302
303STATIC UINT32 HPFWait(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 ticks)
304{
305 runTask->taskStatus |= OS_TASK_STATUS_PENDING;
306 LOS_ListTailInsert(list, &runTask->pendList);
307
308 if (ticks != LOS_WAIT_FOREVER) {
309 runTask->taskStatus |= OS_TASK_STATUS_PEND_TIME;
310 runTask->waitTime = OS_SCHED_TICK_TO_CYCLE(ticks);
311 }
312
313 if (OsPreemptableInSched()) {
315 if (runTask->taskStatus & OS_TASK_STATUS_TIMEOUT) {
316 runTask->taskStatus &= ~OS_TASK_STATUS_TIMEOUT;
317 return LOS_ERRNO_TSK_TIMEOUT;
318 }
319 }
320
321 return LOS_OK;
322}
323
324STATIC VOID HPFWake(LosTaskCB *resumedTask)
325{
326 LOS_ListDelete(&resumedTask->pendList);
327 resumedTask->taskStatus &= ~OS_TASK_STATUS_PENDING;
328
329 if (resumedTask->taskStatus & OS_TASK_STATUS_PEND_TIME) {
330 OsSchedTimeoutQueueDelete(resumedTask);
331 resumedTask->taskStatus &= ~OS_TASK_STATUS_PEND_TIME;
332 }
333
334 if (!(resumedTask->taskStatus & OS_TASK_STATUS_SUSPENDED)) {
335#ifdef LOSCFG_SCHED_DEBUG
336 resumedTask->schedStat.pendTime += OsGetCurrSchedTimeCycle() - resumedTask->startTime;
337 resumedTask->schedStat.pendCount++;
338#endif
339 HPFEnqueue(OsSchedRunqueue(), resumedTask);
340 }
341}
342
344{
345 LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
346 BOOL needSched = FALSE;
347
348 LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
349 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
350 if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
351 taskCB->ops->dequeue(rq, taskCB);
352 sched->basePrio = priority;
353 taskCB->ops->enqueue(rq, taskCB);
354 } else {
355 sched->basePrio = priority;
356 }
357 if (taskCB->taskStatus & (OS_TASK_STATUS_READY | OS_TASK_STATUS_RUNNING)) {
358 needSched = TRUE;
359 }
360 }
361
362 return needSched;
363}
364
365STATIC BOOL HPFSchedParamModify(LosTaskCB *taskCB, const SchedParam *param)
366{
368 BOOL needSched = FALSE;
369 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
370
371 if (sched->policy != param->policy) {
372 sched->policy = param->policy;
373 taskCB->timeSlice = 0;
374 }
375
376 if (sched->basePrio != param->basePrio) {
377 needSched = BasePriorityModify(rq, taskCB, param->basePrio);
378 }
379
380 if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
381 HPFDequeue(rq, taskCB);
382 sched->priority = param->priority;
383 HPFEnqueue(rq, taskCB);
384 return TRUE;
385 }
386
387 sched->priority = param->priority;
388 OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, sched->priority);
389 if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
390 HPFEnqueue(rq, taskCB);
391 return TRUE;
392 }
393
394 if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
395 return TRUE;
396 }
397
398 return needSched;
399}
400
401STATIC UINT32 HPFSchedParamGet(const LosTaskCB *taskCB, SchedParam *param)
402{
403 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
404 param->policy = sched->policy;
405 param->basePrio = sched->basePrio;
406 param->priority = sched->priority;
407 param->timeSlice = sched->initTimeSlice;
408 return LOS_OK;
409}
410
412{
413 if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
414 HPFDequeue(OsSchedRunqueue(), taskCB);
415 }
416
417 SchedTaskFreeze(taskCB);
418
419 taskCB->taskStatus |= OS_TASK_STATUS_SUSPENDED;
420 OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTOSUSPENDEDLIST, taskCB);
421 if (taskCB == OsCurrTaskGet()) {
423 }
424 return LOS_OK;
425}
426
427STATIC UINT32 HPFResume(LosTaskCB *taskCB, BOOL *needSched)
428{
429 *needSched = FALSE;
430
431 SchedTaskUnfreeze(taskCB);
432
433 taskCB->taskStatus &= ~OS_TASK_STATUS_SUSPENDED;
434 if (!OsTaskIsBlocked(taskCB)) {
435 HPFEnqueue(OsSchedRunqueue(), taskCB);
436 *needSched = TRUE;
437 }
438
439 return LOS_OK;
440}
441
442STATIC INT32 HPFParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2)
443{
444 SchedHPF *param1 = (SchedHPF *)sp1;
445 SchedHPF *param2 = (SchedHPF *)sp2;
446
447 if (param1->basePrio != param2->basePrio) {
448 return (param1->basePrio - param2->basePrio);
449 }
450
451 return (param1->priority - param2->priority);
452}
453
454STATIC VOID HPFPriorityInheritance(LosTaskCB *owner, const SchedParam *param)
455{
456 SchedHPF *sp = (SchedHPF *)&owner->sp;
457
458 if ((param->policy != LOS_SCHED_RR) && (param->policy != LOS_SCHED_FIFO)) {
459 return;
460 }
461
462 if (sp->priority <= param->priority) {
463 return;
464 }
465
466 LOS_BitmapSet(&sp->priBitmap, sp->priority);
467 sp->priority = param->priority;
468}
469/// 恢复任务优先级
470STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param)
471{
472 UINT16 priority;
473 LosTaskCB *pendedTask = NULL;
474
475 if ((param->policy != LOS_SCHED_RR) && (param->policy != LOS_SCHED_FIFO)) {
476 return;
477 }
478
479 SchedHPF *sp = (SchedHPF *)&owner->sp;
480 if (sp->priority < param->priority) {
481 if (LOS_HighBitGet(sp->priBitmap) != param->priority) {
482 LOS_BitmapClr(&sp->priBitmap, param->priority);
483 }
484 return;
485 }
486
487 if (sp->priBitmap == 0) {
488 return;
489 }
490
491 if ((list != NULL) && !LOS_ListEmpty((LOS_DL_LIST *)list)) {
492 priority = LOS_HighBitGet(sp->priBitmap);//获取在历史调度中最高优先级
493 LOS_DL_LIST_FOR_EACH_ENTRY(pendedTask, list, LosTaskCB, pendList) {//遍历链表
494 SchedHPF *pendSp = (SchedHPF *)&pendedTask->sp;
495 if ((pendedTask->ops == owner->ops) && (priority != pendSp->priority)) {
496 LOS_BitmapClr(&sp->priBitmap, pendSp->priority);
497 }
498 }
499 }
500
501 priority = LOS_LowBitGet(sp->priBitmap);
502 if (priority != LOS_INVALID_BIT_INDEX) {
503 LOS_BitmapClr(&sp->priBitmap, priority);
504 sp->priority = priority;
505 }
506}
507
509 const SchedParam *parentParam,
510 const TSK_INIT_PARAM_S *param)
511{
512 SchedHPF *sched = (SchedHPF *)&taskCB->sp;
513
514 sched->policy = policy;
515 if (param != NULL) {
516 sched->priority = param->usTaskPrio;
517 } else {
518 sched->priority = parentParam->priority;
519 }
520 sched->basePrio = parentParam->basePrio;
521
522 sched->initTimeSlice = 0;
523 taskCB->timeSlice = sched->initTimeSlice;
524 taskCB->ops = &g_priorityOps;
525}
526
528{
529 param->basePrio = OS_USER_PROCESS_PRIORITY_HIGHEST;
530}
531//HPF 调度策略初始化
533{
534 if (ArchCurrCpuid() > 0) {
535 rq->hpfRunqueue = &g_schedHPF;
536 return;
537 }
538
539 for (UINT16 index = 0; index < OS_PRIORITY_QUEUE_NUM; index++) {
540 HPFQueue *queueList = &g_schedHPF.queueList[index];
541 LOS_DL_LIST *priQue = &queueList->priQueList[0];
542 for (UINT16 prio = 0; prio < OS_PRIORITY_QUEUE_NUM; prio++) {
543 LOS_ListInit(&priQue[prio]);
544 }
545 }
546
547 rq->hpfRunqueue = &g_schedHPF;
548}
macro EXC_SP_SET reg1 mrc 获取CPU信息 and mov mul reg0 计算当前CPU栈的偏移位置 ldr reg1 相减得到栈顶 mov sp
Definition: asm.h:57
VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
对状态字的某一标志位进行置1操作
Definition: los_bitmap.c:60
VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
对状态字的某一标志位进行清0操作
Definition: los_bitmap.c:69
UINT16 LOS_LowBitGet(UINT32 bitmap)
获取参数位图中最低位为1的索引位, 例如: 00110110 返回 1
Definition: los_bitmap.c:97
UINT16 LOS_HighBitGet(UINT32 bitmap)
获取参数位图中最高位为1的索引位 例如: 00110110 返回 5
Definition: los_bitmap.c:88
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListInit(LOS_DL_LIST *list)
Definition: los_list.h:104
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListTailInsert(LOS_DL_LIST *list, LOS_DL_LIST *node)
Insert a node to the tail of a doubly linked list.
Definition: los_list.h:244
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListHeadInsert(LOS_DL_LIST *list, LOS_DL_LIST *node)
Insert a node to the head of a doubly linked list.
Definition: los_list.h:268
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelete(LOS_DL_LIST *node)
Definition: los_list.h:292
LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_ListEmpty(LOS_DL_LIST *list)
Identify whether a specified doubly linked list is empty. | 判断链表是否为空
Definition: los_list.h:321
STATIC INLINE UINT32 ArchCurrCpuid(VOID)
Definition: los_hw_cpu.h:168
STATIC VOID HPFDequeue(SchedRunqueue *rq, LosTaskCB *taskCB)
Definition: los_priority.c:254
STATIC VOID HPFPriorityInheritance(LosTaskCB *owner, const SchedParam *param)
Definition: los_priority.c:454
STATIC UINT32 HPFDelay(LosTaskCB *runTask, UINT64 waitTime)
Definition: los_priority.c:294
STATIC BOOL BasePriorityModify(SchedRunqueue *rq, LosTaskCB *taskCB, UINT16 priority)
Definition: los_priority.c:343
STATIC INLINE VOID PriQueInsert(HPFRunqueue *rq, LosTaskCB *taskCB)
Definition: los_priority.c:204
STATIC UINT32 HPFSuspend(LosTaskCB *taskCB)
Definition: los_priority.c:411
STATIC UINT32 HPFSchedParamGet(const LosTaskCB *taskCB, SchedParam *param)
Definition: los_priority.c:401
STATIC VOID HPFYield(LosTaskCB *runTask)
Definition: los_priority.c:284
const STATIC SchedOps g_priorityOps
Definition: los_priority.c:68
STATIC INLINE UINT32 TimeSliceCalculate(HPFRunqueue *rq, UINT16 basePrio, UINT16 priority)
Definition: los_priority.c:123
STATIC VOID HPFEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB)
Definition: los_priority.c:244
STATIC VOID HPFExit(LosTaskCB *taskCB)
Definition: los_priority.c:269
STATIC INT32 HPFParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2)
Definition: los_priority.c:442
STATIC INLINE VOID PriQueDelete(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
Definition: los_priority.c:187
STATIC VOID HPFStartToRun(SchedRunqueue *rq, LosTaskCB *taskCB)
Definition: los_priority.c:264
STATIC UINT32 HPFWait(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 ticks)
Definition: los_priority.c:303
STATIC INLINE VOID PriQueHeadInsert(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
Definition: los_priority.c:137
STATIC UINT32 HPFResume(LosTaskCB *taskCB, BOOL *needSched)
Definition: los_priority.c:427
VOID HPFSchedPolicyInit(SchedRunqueue *rq)
Definition: los_priority.c:532
STATIC VOID HPFTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime)
Definition: los_priority.c:88
VOID HPFProcessDefaultSchedParamGet(SchedParam *param)
Definition: los_priority.c:527
STATIC INLINE VOID PriQueTailInsert(HPFRunqueue *rq, UINT32 basePrio, LOS_DL_LIST *priQue, UINT32 priority)
Definition: los_priority.c:162
STATIC BOOL HPFSchedParamModify(LosTaskCB *taskCB, const SchedParam *param)
Definition: los_priority.c:365
STATIC UINT64 HPFTimeSliceGet(const LosTaskCB *taskCB)
Definition: los_priority.c:114
STATIC HPFRunqueue g_schedHPF
Definition: los_priority.c:48
VOID HPFTaskSchedParamInit(LosTaskCB *taskCB, UINT16 policy, const SchedParam *parentParam, const TSK_INIT_PARAM_S *param)
Definition: los_priority.c:508
STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param)
恢复任务优先级
Definition: los_priority.c:470
STATIC VOID HPFWake(LosTaskCB *resumedTask)
Definition: los_priority.c:324
STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
Definition: los_sched_pri.h:75
STATIC INLINE LosTaskCB * OsCurrTaskGet(VOID)
STATIC INLINE BOOL OsPreemptableInSched(VOID)
STATIC INLINE SchedRunqueue * OsSchedRunqueue(VOID)
STATIC INLINE VOID SchedTaskFreeze(LosTaskCB *taskCB)
STATIC INLINE VOID OsSchedTimeoutQueueDelete(LosTaskCB *taskCB)
STATIC INLINE VOID SchedTaskUnfreeze(LosTaskCB *taskCB)
STATIC INLINE BOOL OsTaskIsBlocked(const LosTaskCB *taskCB)
@ INT_PEND_RESCH
Definition: los_sched_pri.h:82
VOID OsSchedResched(VOID)
Definition: los_sched.c:449
unsigned short UINT16
Definition: los_typedef.h:56
signed int INT32
Definition: los_typedef.h:60
long unsigned int UINT64
Definition: los_typedef.h:66
unsigned int UINT32
Definition: los_typedef.h:57
size_t BOOL
Definition: los_typedef.h:88
UINT32 queueBitmap
Definition: los_sched_pri.h:90
UINT32 readyTasks[OS_PRIORITY_QUEUE_NUM]
Definition: los_sched_pri.h:89
LOS_DL_LIST priQueList[OS_PRIORITY_QUEUE_NUM]
Definition: los_sched_pri.h:88
UINT32 queueBitmap
Definition: los_sched_pri.h:95
HPFQueue queueList[OS_PRIORITY_QUEUE_NUM]
Definition: los_sched_pri.h:94
struct LOS_DL_LIST * pstNext
Definition: los_list.h:84
LOS_DL_LIST threadSiblingList
UINT16 priority
当前优先级
UINT16 policy
UINT32 initTimeSlice
初始化时间片
UINT16 basePrio
起始优先级
VOID(* enqueue)(SchedRunqueue *rq, LosTaskCB *taskCB)
入队列
VOID(* dequeue)(SchedRunqueue *rq, LosTaskCB *taskCB)
出队列
UINT16 basePrio
UINT16 policy
UINT16 priority
UINT32 timeSlice
HPFRunqueue * hpfRunqueue
UINT64 timeSliceCount
UINT64 timeSliceTime
UINT64 timeSliceRealTime
INT32 timeSlice
UINT64 startTime
UINT32 irqUsedTime
LOS_DL_LIST pendList
UINT64 waitTime
SchedPolicy sp
UINT32 processID
const SchedOps * ops
SchedStat schedStat
UINT16 taskStatus
UINT16 usTaskPrio
Definition: los_task.h:505
if(tv==NULL)
Definition: time.c:430
time_t time(time_t *t)
Definition: time.c:1224