los_sched_pri.h 20.7 KB
Newer Older
W
wenjun 已提交
1
/*
M
mamingshuai 已提交
2
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
Z
zhushengle 已提交
3
 * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
W
wenjun 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 *    conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 *    of conditions and the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _LOS_SCHED_PRI_H
#define _LOS_SCHED_PRI_H

35
#include "los_sortlink_pri.h"
M
mamingshuai 已提交
36
#include "los_sys_pri.h"
W
wenjun 已提交
37
#include "los_hwi.h"
M
mamingshuai 已提交
38
#include "hal_timer.h"
39
#ifdef LOSCFG_SCHED_DEBUG
Z
zhushengle 已提交
40
#include "los_statistics_pri.h"
41 42 43
#endif
#include "los_stackinfo_pri.h"
#include "los_futex_pri.h"
44
#ifdef LOSCFG_KERNEL_PM
Z
zhushengle 已提交
45
#include "los_pm_pri.h"
46
#endif
47 48 49 50 51 52 53
#include "los_signal.h"
#ifdef LOSCFG_KERNEL_CPUP
#include "los_cpup_pri.h"
#endif
#ifdef LOSCFG_KERNEL_LITEIPC
#include "hm_liteipc.h"
#endif
54
#include "los_mp.h"
Z
zhushengle 已提交
55 56 57
#ifdef LOSCFG_KERNEL_CONTAINER
#include "los_container_pri.h"
#endif
W
wenjun 已提交
58 59 60 61 62 63 64

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */

65 66 67 68 69
#define OS_SCHED_MINI_PERIOD          (OS_SYS_CLOCK / LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI)
#define OS_TICK_RESPONSE_PRECISION    (UINT32)((OS_SCHED_MINI_PERIOD * 75) / 100)
#define OS_SCHED_MAX_RESPONSE_TIME    OS_SORT_LINK_INVALID_TIME
#define OS_SCHED_TICK_TO_CYCLE(ticks) ((UINT64)ticks * OS_CYCLE_PER_TICK)
#define AFFI_MASK_TO_CPUID(mask)      ((UINT16)((mask) - 1))
70

W
wenjun 已提交
71
extern UINT32 g_taskScheduled;
72 73
#define OS_SCHEDULER_ACTIVE (g_taskScheduled & (1U << ArchCurrCpuid()))
#define OS_SCHEDULER_ALL_ACTIVE (g_taskScheduled == LOSCFG_KERNEL_CPU_MASK)
M
mamingshuai 已提交
74

Z
zhushengle 已提交
75
typedef struct TagTaskCB LosTaskCB;
76 77
typedef BOOL (*SCHED_TL_FIND_FUNC)(UINTPTR, UINTPTR);

78 79 80 81 82
STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
{
    return HalClockGetCycles();
}

83 84 85 86 87 88
typedef enum {
    INT_NO_RESCH = 0x0,   /* no needs to schedule */
    INT_PEND_RESCH = 0x1, /* pending schedule flag */
    INT_PEND_TICK = 0x2,  /* pending tick */
} SchedFlag;

Z
zhushengle 已提交
89
#define OS_PRIORITY_QUEUE_NUM 32
90
typedef struct {
Z
zhushengle 已提交
91 92 93 94
    LOS_DL_LIST priQueList[OS_PRIORITY_QUEUE_NUM];
    UINT32      readyTasks[OS_PRIORITY_QUEUE_NUM];
    UINT32      queueBitmap;
} HPFQueue;
95

Z
zhushengle 已提交
96 97 98 99 100 101 102 103 104 105
typedef struct {
    HPFQueue queueList[OS_PRIORITY_QUEUE_NUM];
    UINT32   queueBitmap;
} HPFRunqueue;

typedef struct {
    SortLinkAttribute timeoutQueue; /* task timeout queue */
    HPFRunqueue       *hpfRunqueue;
    UINT64            responseTime; /* Response time for current CPU tick interrupts */
    UINT32            responseID;   /* The response ID of the current CPU tick interrupt */
Z
zhushengle 已提交
106
    LosTaskCB         *idleTask;   /* idle task id */
Z
zhushengle 已提交
107 108 109 110 111
    UINT32            taskLockCnt;  /* task lock flag */
    UINT32            schedFlag;    /* pending scheduler flag */
} SchedRunqueue;

extern SchedRunqueue g_schedRunqueue[LOSCFG_KERNEL_CORE_NUM];
112

Z
zhushengle 已提交
113
VOID OsSchedExpireTimeUpdate(VOID);
114

Z
zhushengle 已提交
115
STATIC INLINE SchedRunqueue *OsSchedRunqueue(VOID)
M
mamingshuai 已提交
116
{
Z
zhushengle 已提交
117
    return &g_schedRunqueue[ArchCurrCpuid()];
M
mamingshuai 已提交
118 119
}

Z
zhushengle 已提交
120
STATIC INLINE SchedRunqueue *OsSchedRunqueueByID(UINT16 id)
M
mamingshuai 已提交
121
{
Z
zhushengle 已提交
122
    return &g_schedRunqueue[id];
M
mamingshuai 已提交
123 124
}

125
STATIC INLINE UINT32 OsSchedLockCountGet(VOID)
M
mamingshuai 已提交
126
{
Z
zhushengle 已提交
127
    return OsSchedRunqueue()->taskLockCnt;
M
mamingshuai 已提交
128
}
W
wenjun 已提交
129

130 131
STATIC INLINE VOID OsSchedLockSet(UINT32 count)
{
Z
zhushengle 已提交
132
    OsSchedRunqueue()->taskLockCnt = count;
133
}
W
wenjun 已提交
134

135 136
STATIC INLINE VOID OsSchedLock(VOID)
{
Z
zhushengle 已提交
137
    OsSchedRunqueue()->taskLockCnt++;
138
}
W
wenjun 已提交
139

140 141
STATIC INLINE VOID OsSchedUnlock(VOID)
{
Z
zhushengle 已提交
142
    OsSchedRunqueue()->taskLockCnt--;
143
}
W
wenjun 已提交
144

145 146
STATIC INLINE BOOL OsSchedUnlockResch(VOID)
{
Z
zhushengle 已提交
147
    SchedRunqueue *rq = OsSchedRunqueue();
148 149 150 151 152 153 154 155 156 157 158 159
    if (rq->taskLockCnt > 0) {
        rq->taskLockCnt--;
        if ((rq->taskLockCnt == 0) && (rq->schedFlag & INT_PEND_RESCH) && OS_SCHEDULER_ACTIVE) {
            return TRUE;
        }
    }

    return FALSE;
}

STATIC INLINE BOOL OsSchedIsLock(VOID)
{
Z
zhushengle 已提交
160
    return (OsSchedRunqueue()->taskLockCnt != 0);
161
}
W
wenjun 已提交
162

163
/* Check if preemptible with counter flag */
W
wenjun 已提交
164 165
STATIC INLINE BOOL OsPreemptable(VOID)
{
Z
zhushengle 已提交
166
    SchedRunqueue *rq = OsSchedRunqueue();
W
wenjun 已提交
167 168
    /*
     * Unlike OsPreemptableInSched, the int may be not disabled when OsPreemptable
169 170
     * is called, needs manually disable interrupt, to prevent current task from
     * being migrated to another core, and get the wrong preemptable status.
W
wenjun 已提交
171 172
     */
    UINT32 intSave = LOS_IntLock();
173 174
    BOOL preemptible = (rq->taskLockCnt == 0);
    if (!preemptible) {
W
wenjun 已提交
175
        /* Set schedule flag if preemption is disabled */
176
        rq->schedFlag |= INT_PEND_RESCH;
W
wenjun 已提交
177 178
    }
    LOS_IntRestore(intSave);
179
    return preemptible;
W
wenjun 已提交
180 181 182 183
}

STATIC INLINE BOOL OsPreemptableInSched(VOID)
{
184
    BOOL preemptible = FALSE;
Z
zhushengle 已提交
185
    SchedRunqueue *rq = OsSchedRunqueue();
W
wenjun 已提交
186

187
#ifdef LOSCFG_KERNEL_SMP
W
wenjun 已提交
188 189 190 191
    /*
     * For smp systems, schedule must hold the task spinlock, and this counter
     * will increase by 1 in that case.
     */
192
    preemptible = (rq->taskLockCnt == 1);
W
wenjun 已提交
193 194

#else
195
    preemptible = (rq->taskLockCnt == 0);
W
wenjun 已提交
196
#endif
197
    if (!preemptible) {
W
wenjun 已提交
198
        /* Set schedule flag if preemption is disabled */
199
        rq->schedFlag |= INT_PEND_RESCH;
W
wenjun 已提交
200 201
    }

202
    return preemptible;
W
wenjun 已提交
203 204
}

Z
zhushengle 已提交
205
STATIC INLINE LosTaskCB *OsSchedRunqueueIdleGet(VOID)
M
mamingshuai 已提交
206
{
Z
zhushengle 已提交
207
    return OsSchedRunqueue()->idleTask;
M
mamingshuai 已提交
208 209
}

Z
zhushengle 已提交
210
STATIC INLINE VOID OsSchedRunqueuePendingSet(VOID)
M
mamingshuai 已提交
211
{
Z
zhushengle 已提交
212
    OsSchedRunqueue()->schedFlag |= INT_PEND_RESCH;
M
mamingshuai 已提交
213 214
}

Z
zhushengle 已提交
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
#define LOS_SCHED_NORMAL  0U
#define LOS_SCHED_FIFO    1U
#define LOS_SCHED_RR      2U
#define LOS_SCHED_IDLE    3U

typedef struct {
    UINT16 policy;
    UINT16 basePrio;
    UINT16 priority;
    UINT32 timeSlice;
} SchedParam;

typedef struct {
    UINT16  policy; /* This field must be present for all scheduling policies and must be the first in the structure */
    UINT16  basePrio;
    UINT16  priority;
    UINT32  initTimeSlice;
    UINT32  priBitmap; /**< Bitmap for recording the change of task priority, the priority can not be greater than 31 */
} SchedHPF;

typedef struct {
    union {
        SchedHPF hpf;
    } Policy;
} SchedPolicy;

typedef struct {
    VOID (*dequeue)(SchedRunqueue *rq, LosTaskCB *taskCB);
    VOID (*enqueue)(SchedRunqueue *rq, LosTaskCB *taskCB);
    VOID (*start)(SchedRunqueue *rq, LosTaskCB *taskCB);
    VOID (*exit)(LosTaskCB *taskCB);
    UINT32 (*wait)(LosTaskCB *runTask, LOS_DL_LIST *list, UINT32 timeout);
    VOID (*wake)(LosTaskCB *taskCB);
    BOOL (*schedParamModify)(LosTaskCB *taskCB, const SchedParam *param);
    UINT32 (*schedParamGet)(const LosTaskCB *taskCB, SchedParam *param);
    UINT32 (*delay)(LosTaskCB *taskCB, UINT64 waitTime);
    VOID (*yield)(LosTaskCB *taskCB);
    UINT32 (*suspend)(LosTaskCB *taskCB);
    UINT32 (*resume)(LosTaskCB *taskCB, BOOL *needSched);
    UINT64 (*deadlineGet)(const LosTaskCB *taskCB);
    VOID (*timeSliceUpdate)(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 currTime);
    INT32 (*schedParamCompare)(const SchedPolicy *sp1, const SchedPolicy *sp2);
    VOID (*priorityInheritance)(LosTaskCB *owner, const SchedParam *param);
    VOID (*priorityRestore)(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param);
} SchedOps;
Z
zhushengle 已提交
260

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
/**
 * @ingroup los_sched
 * Define a usable task priority.
 *
 * Highest task priority.
 */
#define OS_TASK_PRIORITY_HIGHEST    0

/**
 * @ingroup los_sched
 * Define a usable task priority.
 *
 * Lowest task priority.
 */
#define OS_TASK_PRIORITY_LOWEST     31

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is init.
 */
#define OS_TASK_STATUS_INIT         0x0001U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is ready.
 */
#define OS_TASK_STATUS_READY        0x0002U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is running.
 */
#define OS_TASK_STATUS_RUNNING      0x0004U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is suspended.
 */
#define OS_TASK_STATUS_SUSPENDED    0x0008U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is blocked.
 */
#define OS_TASK_STATUS_PENDING      0x0010U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is delayed.
 */
#define OS_TASK_STATUS_DELAY        0x0020U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The time for waiting for an event to occur expires.
 */
#define OS_TASK_STATUS_TIMEOUT      0x0040U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is pend for a period of time.
 */
#define OS_TASK_STATUS_PEND_TIME    0x0080U

/**
 * @ingroup los_sched
 * Flag that indicates the task or task control block status.
 *
 * The task is exit.
 */
#define OS_TASK_STATUS_EXIT         0x0100U

Z
zhushengle 已提交
349 350 351 352 353 354 355 356 357 358 359
#define OS_TASK_STATUS_BLOCKED     (OS_TASK_STATUS_INIT | OS_TASK_STATUS_PENDING | \
                                    OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)

/**
 * @ingroup los_task
 * Flag that indicates the task or task control block status.
 *
 * The delayed operation of this task is frozen.
 */
#define OS_TASK_STATUS_FROZEN       0x0200U

360 361
#define OS_TCB_NAME_LEN             32

Z
zhushengle 已提交
362
typedef struct TagTaskCB {
363 364 365 366
    VOID            *stackPointer;      /**< Task stack pointer */
    UINT16          taskStatus;         /**< Task status */

    UINT64          startTime;          /**< The start time of each phase of task */
367
    UINT64          waitTime;           /**< Task delay time, tick number */
368 369 370 371
    UINT64          irqStartTime;       /**< Interrupt start time */
    UINT32          irqUsedTime;        /**< Interrupt consumption time */
    INT32           timeSlice;          /**< Task remaining time slice */
    SortLinkList    sortList;           /**< Task sortlink node */
Z
zhushengle 已提交
372 373
    const SchedOps  *ops;
    SchedPolicy     sp;
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414

    UINT32          stackSize;          /**< Task stack size */
    UINTPTR         topOfStack;         /**< Task stack top */
    UINT32          taskID;             /**< Task ID */
    TSK_ENTRY_FUNC  taskEntry;          /**< Task entrance function */
    VOID            *joinRetval;        /**< pthread adaption */
    VOID            *taskMux;           /**< Task-held mutex */
    VOID            *taskEvent;         /**< Task-held event */
    UINTPTR         args[4];            /**< Parameter, of which the maximum number is 4 */
    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */
    LOS_DL_LIST     pendList;           /**< Task pend node */
    LOS_DL_LIST     threadList;         /**< thread list */
    UINT32          eventMask;          /**< Event mask */
    UINT32          eventMode;          /**< Event mode */
#ifdef LOSCFG_KERNEL_CPUP
    OsCpupBase      taskCpup;           /**< task cpu usage */
#endif
    INT32           errorNo;            /**< Error Num */
    UINT32          signal;             /**< Task signal */
    sig_cb          sig;
#ifdef LOSCFG_KERNEL_SMP
    UINT16          currCpu;            /**< CPU core number of this task is running on */
    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */
    UINT16          cpuAffiMask;        /**< CPU affinity mask, support up to 16 cores */
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
    UINT32          syncSignal;         /**< Synchronization for signal handling */
#endif
#ifdef LOSCFG_KERNEL_SMP_LOCKDEP
    LockDep         lockDep;
#endif
#endif
#ifdef LOSCFG_SCHED_DEBUG
    SchedStat       schedStat;          /**< Schedule statistics */
#endif
#ifdef LOSCFG_KERNEL_VM
    UINTPTR         archMmu;
    UINTPTR         userArea;
    UINTPTR         userMapBase;
    UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
    FutexNode       futex;
#endif
Z
zhushengle 已提交
415
    UINTPTR         processCB;          /**< Which belong process */
416 417 418 419 420 421 422 423 424 425 426 427
    LOS_DL_LIST     joinList;           /**< join list */
    LOS_DL_LIST     lockList;           /**< Hold the lock list */
    UINTPTR         waitID;             /**< Wait for the PID or GID of the child process */
    UINT16          waitFlag;           /**< The type of child process that is waiting, belonging to a group or parent,
                                             a specific child process, or any child process */
#ifdef LOSCFG_KERNEL_LITEIPC
    IpcTaskInfo     *ipcTaskInfo;
#endif
#ifdef LOSCFG_KERNEL_PERF
    UINTPTR         pc;
    UINTPTR         fp;
#endif
Z
zhushengle 已提交
428 429 430
#ifdef LOSCFG_PID_CONTAINER
    PidContainer    *pidContainer;
#endif
431 432 433
} LosTaskCB;

STATIC INLINE BOOL OsTaskIsRunning(const LosTaskCB *taskCB)
434
{
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    return ((taskCB->taskStatus & OS_TASK_STATUS_RUNNING) != 0);
}

STATIC INLINE BOOL OsTaskIsReady(const LosTaskCB *taskCB)
{
    return ((taskCB->taskStatus & OS_TASK_STATUS_READY) != 0);
}

STATIC INLINE BOOL OsTaskIsInactive(const LosTaskCB *taskCB)
{
    return ((taskCB->taskStatus & (OS_TASK_STATUS_INIT | OS_TASK_STATUS_EXIT)) != 0);
}

STATIC INLINE BOOL OsTaskIsPending(const LosTaskCB *taskCB)
{
    return ((taskCB->taskStatus & OS_TASK_STATUS_PENDING) != 0);
}

STATIC INLINE BOOL OsTaskIsSuspended(const LosTaskCB *taskCB)
{
    return ((taskCB->taskStatus & OS_TASK_STATUS_SUSPENDED) != 0);
}

STATIC INLINE BOOL OsTaskIsBlocked(const LosTaskCB *taskCB)
{
    return ((taskCB->taskStatus & (OS_TASK_STATUS_SUSPENDED | OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY)) != 0);
}

STATIC INLINE LosTaskCB *OsCurrTaskGet(VOID)
{
    return (LosTaskCB *)ArchCurrTaskGet();
}

STATIC INLINE VOID OsCurrTaskSet(LosTaskCB *task)
{
    ArchCurrTaskSet(task);
}

STATIC INLINE VOID OsCurrUserTaskSet(UINTPTR thread)
{
    ArchCurrUserTaskSet(thread);
476
}
M
mamingshuai 已提交
477

Z
zhushengle 已提交
478
STATIC INLINE VOID OsSchedIrqUsedTimeUpdate(VOID)
479 480 481 482
{
    LosTaskCB *runTask = OsCurrTaskGet();
    runTask->irqUsedTime = OsGetCurrSchedTimeCycle() - runTask->irqStartTime;
}
M
mamingshuai 已提交
483

484 485 486 487 488
STATIC INLINE VOID OsSchedIrqStartTime(VOID)
{
    LosTaskCB *runTask = OsCurrTaskGet();
    runTask->irqStartTime = OsGetCurrSchedTimeCycle();
}
M
mamingshuai 已提交
489

490
#ifdef LOSCFG_KERNEL_SMP
Z
zhushengle 已提交
491
STATIC INLINE VOID IdleRunqueueFind(UINT16 *idleCpuid)
492
{
Z
zhushengle 已提交
493 494
    SchedRunqueue *idleRq = OsSchedRunqueueByID(0);
    UINT32 nodeNum = OsGetSortLinkNodeNum(&idleRq->timeoutQueue);
495 496
    UINT16 cpuid = 1;
    do {
Z
zhushengle 已提交
497 498
        SchedRunqueue *rq = OsSchedRunqueueByID(cpuid);
        UINT32 temp = OsGetSortLinkNodeNum(&rq->timeoutQueue);
499 500 501 502 503 504 505 506 507
        if (nodeNum > temp) {
            *idleCpuid = cpuid;
            nodeNum = temp;
        }
        cpuid++;
    } while (cpuid < LOSCFG_KERNEL_CORE_NUM);
}
#endif

Z
zhushengle 已提交
508
STATIC INLINE VOID OsSchedTimeoutQueueAdd(LosTaskCB *taskCB, UINT64 responseTime)
509 510 511 512 513
{
#ifdef LOSCFG_KERNEL_SMP
    UINT16 cpuid = AFFI_MASK_TO_CPUID(taskCB->cpuAffiMask);
    if (cpuid >= LOSCFG_KERNEL_CORE_NUM) {
        cpuid = 0;
Z
zhushengle 已提交
514
        IdleRunqueueFind(&cpuid);
515 516 517 518 519
    }
#else
    UINT16 cpuid = 0;
#endif

Z
zhushengle 已提交
520 521
    SchedRunqueue *rq = OsSchedRunqueueByID(cpuid);
    OsAdd2SortLink(&rq->timeoutQueue, &taskCB->sortList, responseTime, cpuid);
522 523 524 525 526 527 528 529
#ifdef LOSCFG_KERNEL_SMP
    if ((cpuid != ArchCurrCpuid()) && (responseTime < rq->responseTime)) {
        rq->schedFlag |= INT_PEND_TICK;
        LOS_MpSchedule(CPUID_TO_AFFI_MASK(cpuid));
    }
#endif
}

Z
zhushengle 已提交
530
STATIC INLINE VOID OsSchedTimeoutQueueDelete(LosTaskCB *taskCB)
531 532 533
{
    SortLinkList *node = &taskCB->sortList;
#ifdef LOSCFG_KERNEL_SMP
Z
zhushengle 已提交
534
    SchedRunqueue *rq = OsSchedRunqueueByID(node->cpuid);
535
#else
Z
zhushengle 已提交
536
    SchedRunqueue *rq = OsSchedRunqueueByID(0);
537 538
#endif
    UINT64 oldResponseTime = GET_SORTLIST_VALUE(node);
Z
zhushengle 已提交
539
    OsDeleteFromSortLink(&rq->timeoutQueue, node);
540 541 542 543 544
    if (oldResponseTime <= rq->responseTime) {
        rq->responseTime = OS_SCHED_MAX_RESPONSE_TIME;
    }
}

Z
zhushengle 已提交
545
STATIC INLINE UINT32 OsSchedTimeoutQueueAdjust(LosTaskCB *taskCB, UINT64 responseTime)
546 547 548 549 550 551 552 553
{
    UINT32 ret;
    SortLinkList *node = &taskCB->sortList;
#ifdef LOSCFG_KERNEL_SMP
    UINT16 cpuid = node->cpuid;
#else
    UINT16 cpuid = 0;
#endif
Z
zhushengle 已提交
554 555
    SchedRunqueue *rq = OsSchedRunqueueByID(cpuid);
    ret = OsSortLinkAdjustNodeResponseTime(&rq->timeoutQueue, node, responseTime);
556 557 558 559 560 561
    if (ret == LOS_OK) {
        rq->schedFlag |= INT_PEND_TICK;
    }
    return ret;
}

Z
zhushengle 已提交
562 563 564 565
STATIC INLINE VOID SchedTaskFreeze(LosTaskCB *taskCB)
{
    UINT64 responseTime;

566
#ifdef LOSCFG_KERNEL_PM
Z
zhushengle 已提交
567 568 569
    if (!OsIsPmMode()) {
        return;
    }
570
#endif
Z
zhushengle 已提交
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606

    if (!(taskCB->taskStatus & (OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY))) {
        return;
    }

    responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
    OsSchedTimeoutQueueDelete(taskCB);
    SET_SORTLIST_VALUE(&taskCB->sortList, responseTime);
    taskCB->taskStatus |= OS_TASK_STATUS_FROZEN;
    return;
}

STATIC INLINE VOID SchedTaskUnfreeze(LosTaskCB *taskCB)
{
    UINT64 currTime, responseTime;

    if (!(taskCB->taskStatus & OS_TASK_STATUS_FROZEN)) {
        return;
    }

    taskCB->taskStatus &= ~OS_TASK_STATUS_FROZEN;
    currTime = OsGetCurrSchedTimeCycle();
    responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
    if (responseTime > currTime) {
        OsSchedTimeoutQueueAdd(taskCB, responseTime);
        return;
    }

    SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME);
    if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) {
        LOS_ListDelete(&taskCB->pendList);
    }
    taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED;
    return;
}

607 608 609 610 611 612 613
/*
 * Schedule flag, one bit represents one core.
 * This flag is used to prevent kernel scheduling before OSStartToRun.
 */
#define OS_SCHEDULER_SET(cpuid) do {     \
    g_taskScheduled |= (1U << (cpuid));  \
} while (0);
M
mamingshuai 已提交
614

615 616 617
#define OS_SCHEDULER_CLR(cpuid) do {     \
    g_taskScheduled &= ~(1U << (cpuid)); \
} while (0);
M
mamingshuai 已提交
618

Z
zhushengle 已提交
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
STATIC INLINE LosTaskCB *HPFRunqueueTopTaskGet(HPFRunqueue *rq)
{
    LosTaskCB *newTask = NULL;
    UINT32 baseBitmap = rq->queueBitmap;
#ifdef LOSCFG_KERNEL_SMP
    UINT32 cpuid = ArchCurrCpuid();
#endif

    while (baseBitmap) {
        UINT32 basePrio = CLZ(baseBitmap);
        HPFQueue *queueList = &rq->queueList[basePrio];
        UINT32 bitmap = queueList->queueBitmap;
        while (bitmap) {
            UINT32 priority = CLZ(bitmap);
            LOS_DL_LIST_FOR_EACH_ENTRY(newTask, &queueList->priQueList[priority], LosTaskCB, pendList) {
#ifdef LOSCFG_KERNEL_SMP
                if (newTask->cpuAffiMask & (1U << cpuid)) {
#endif
                    return newTask;
#ifdef LOSCFG_KERNEL_SMP
                }
#endif
            }
            bitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - priority - 1));
        }
        baseBitmap &= ~(1U << (OS_PRIORITY_QUEUE_NUM - basePrio - 1));
    }

    return NULL;
}

VOID HPFSchedPolicyInit(SchedRunqueue *rq);
VOID HPFTaskSchedParamInit(LosTaskCB *taskCB, UINT16 policy,
                           const SchedParam *parentParam, const TSK_INIT_PARAM_S *param);
VOID HPFProcessDefaultSchedParamGet(SchedParam *param);

VOID IdleTaskSchedParamInit(LosTaskCB *taskCB);

INT32 OsSchedParamCompare(const LosTaskCB *task1, const LosTaskCB *task2);
VOID OsSchedPriorityInheritance(LosTaskCB *owner, const SchedParam *param);
UINT32 OsSchedParamInit(LosTaskCB *taskCB, UINT16 policy,
                        const SchedParam *parentParam, const TSK_INIT_PARAM_S *param);
VOID OsSchedProcessDefaultSchedParamGet(UINT16 policy, SchedParam *param);

VOID OsSchedResponseTimeReset(UINT64 responseTime);
664 665 666 667
VOID OsSchedToUserReleaseLock(VOID);
VOID OsSchedTick(VOID);
UINT32 OsSchedInit(VOID);
VOID OsSchedStart(VOID);
M
mamingshuai 已提交
668

Z
zhushengle 已提交
669
VOID OsSchedRunqueueIdleInit(LosTaskCB *idleTask);
Z
zhushengle 已提交
670 671
VOID OsSchedRunqueueInit(VOID);

W
wenjun 已提交
672 673 674 675 676
/*
 * This function simply picks the next task and switches to it.
 * Current task needs to already be in the right state or the right
 * queues it needs to be in.
 */
677 678
VOID OsSchedResched(VOID);
VOID OsSchedIrqEndCheckNeedSched(VOID);
W
wenjun 已提交
679 680

/*
M
mamingshuai 已提交
681 682 683
* This function inserts the runTask to the lock pending list based on the
* task priority.
*/
684
LOS_DL_LIST *OsSchedLockPendFindPos(const LosTaskCB *runTask, LOS_DL_LIST *lockList);
W
wenjun 已提交
685 686 687 688 689 690 691 692

#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */

#endif /* _LOS_SCHED_PRI_H */