共计 10248 个字符，预计需要花费 26 分钟才能阅读完成。
温馨提示：本文不描述与浮点相关的寄存器的内容，如需了解自行查阅（毕竟我自己也不懂）
调度器的基本概念
TencentOS tiny中提供的任务调度器是基于优先级的全抢占式调度，在系统运行过程中，当有比当前任务优先级更高的任务就绪时，当前任务将立刻被 切出 ，高优先级任务 抢占 处理器运行。
TencentOS tiny内核中也允许创建相同优先级的任务。相同优先级的任务采用时间片轮转方式进行调度（也就是通常说的分时调度器），时间片轮转调度仅在当前系统中 无更高优先级就绪任务 的情况下才有效。
为了保证系统的实时性，系统尽最大可能地保证高优先级的任务得以运行。任务调度的原则是一旦任务状态发生了改变，并且当前运行的任务优先级小于优先级队列中任务最高优先级时，立刻进行任务切换（除非当前系统处于中断处理程序中或禁止任务切换的状态）。
调度器是操作系统的 核心 ，其主要功能就是 实现任务的切换 ，即从就绪列表里面 找到 优先级最高的任务，然后去 执行 该任务。
启动调度器
调度器的启动由 cpu_sched_start 函数来完成，它会被 tos_knl_start 函数调用，这个函数中主要做两件事，首先通过 readyqueue_highest_ready_task_get 函数获取当前系统中处于最高优先级的就绪任务，并且将它赋值给指向当前任务控制块的指针k_curr_task ，然后设置一下系统的状态为运行态KNL_STATE_RUNNING。
当然最重要的是调用汇编代码写的函数 cpu_sched_start 启动调度器，该函数在源码的 arch\arm\arm-v7m 目录下的 port_s.S 汇编文件下，TencentOS tiny支持多种内核的芯片，如 M3/M4/M7 等，不同的芯片该函数的实现方式不同，port_s.S也是 TencentOS tiny 作为软件与 CPU 硬件连接的 桥梁 。以 M4 的cpu_sched_start 举个例子：
__API__ k_err_t tos_knl_start(void)
{if (tos_knl_is_running()) {return K_ERR_KNL_RUNNING;}
k_next_task = readyqueue_highest_ready_task_get();
k_curr_task = k_next_task;
k_knl_state = KNL_STATE_RUNNING;
cpu_sched_start();
return K_ERR_NONE;
}port_sched_start
CPSID I
; set pendsv priority lowest
; otherwise trigger pendsv in port_irq_context_switch will cause a context swich in irq
; that would be a disaster
MOV32 R0, NVIC_SYSPRI14
MOV32 R1, NVIC_PENDSV_PRI
STRB R1, [R0]
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
; k_curr_task = k_next_task
MOV32 R0, k_curr_task
MOV32 R1, k_next_task
LDR R2, [R1]
STR R2, [R0]
; sp = k_next_task->sp
LDR R0, [R2]
; PSP = sp
MSR PSP, R0
; using PSP
MRS R0, CONTROL
ORR R0, R0, #2
MSR CONTROL, R0
ISB
; restore r4-11 from new process stack
LDMFD SP!, {R4 - R11}
IF {FPU} != "SoftVFP"
; ignore EXC_RETURN the first switch
LDMFD SP!, {R0}
ENDIF
; restore r0, r3
LDMFD SP!, {R0 - R3}
; load R12 and LR
LDMFD SP!, {R12, LR}
; load PC and discard xPSR
LDMFD SP!, {R1, R2}
CPSIE I
BX R1Cortex- M 内核关中断指令
从上面的汇编代码，我又想介绍一下 Cortex-M 内核关中断指令，唉~ 感觉还是有点麻烦！
为了快速地开关中断，Cortex- M 内核专门设置了一条 CPS 指令 ，用于操作PRIMASK 寄存器跟 FAULTMASK 寄存器的，这两个寄存器是与屏蔽中断有关的，除此之外 Cortex-M 内核还存在 BASEPRI 寄存器也是与中断有关的，也顺带介绍一下吧。
CPSID I ;PRIMASK=1 ; 关中断
CPSIE I ;PRIMASK=0 ; 开中断
CPSID F ;FAULTMASK=1 ; 关异常
CPSIE F ;FAULTMASK=0 ; 开异常| 寄存器 | 功能 |
|---|---|
| PRIMASK | 它被置 1 后，就关掉所有可屏蔽的异常，只剩下 NMI 和 HardFault FAULT 可以响应 |
| FAULTMASK | 当它置 1 时，只有 NMI 才能响应，所有其它的异常都无法响应（包括 HardFault FAULT） |
| BASEPRI | 这个寄存器最多有 9 位（由表达优先级的位数决定）。它定义了被屏蔽优先级的阈值。当它被设成某个值后，所有优先级号大于等于此值的中断都被关（优先级号越大，优先级越低）。但若被设成 0，则不关闭任何中断 |
更多具体的描述看我以前的文章：RTOS 临界段知识：https://blog.csdn.net/jiejiemcu/article/details/82534974
回归正题
在启动内核调度器过程中需要配置 PendSV 的中断优先级为最低，就是往NVIC_SYSPRI14（0xE000ED22） 地址写入 NVIC_PENDSV_PRI（0xFF）。因为PendSV 都会涉及到系统调度，系统调度的优先级要 低于 系统的其它硬件中断优先级，即优先响应系统中的外部硬件中断，所以 PendSV 的中断优先级要配置为最低，不然很可能在中断上下文中产生任务调度。
PendSV 异常会自动延迟上下文切换的请求，直到其它的 ISR 都完成了处理后才放行。为实现这个机制，需要把 PendSV 编程为最低优先级的异常。如果 OS 检测到某 ISR 正在活动，它将悬起一个 PendSV 异常，以便缓期执行上下文切换。也就是说，只要将 PendSV 的优先级设为最低的，systick 即使是打断了 IRQ，它也不会马上进行上下文切换，而是等到 ISR 执行完，PendSV 服务例程才开始执行，并且在里面执行上下文切换。过程如图所示：
然后获取 MSP 主栈指针的地址，在 Cortex-M 中，0xE000ED08是 SCB_VTOR 寄存器的地址，里面存放的是向量表的起始地址。
加载 k_next_task 指向的任务控制块到 R2，从上一篇文章可知任务控制块的第一个成员就是栈顶指针，所以此时 R2 等于栈顶指针。
ps : 在调度器启动时，
k_next_task与k_curr_task是一样的（k_curr_task = k_next_task）
加载 R2 到R0，然后将栈顶指针 R0 更新到psp，任务执行的时候使用的栈指针是psp。
ps：
sp指针有两个，分别为psp和msp。（可以简单理解为：在任务上下文环境中使用psp，在中断上下文环境使用msp，也不一定是正确的，这是我个人的理解）
以 R0 为基地址，将栈中向上增长的 8 个字的内容加载到 CPU 寄存器 R4~R11，同时R0 也会跟着自增
接着需要加载 R0 ~ R3、R12 以及 LR、PC、xPSR 到 CPU 寄存器组，PC 指针指向的是即将要运行的线程，而 LR 寄存器则指向任务的退出。因为这是第一次启动任务，要全部手动把任务栈上的寄存器弹到硬件里，才能进入第一个任务的上下文，因为一开始并没有第一个任务运行的上下文环境，而在进入 PendSV 的时候需要上文保存，所以需要手动创造任务上下文环境（将这些寄存器加载到 CPU 寄存器组中），第一次的时候此汇编入口函数，sp 是指向一个选好的任务的栈顶（k_curr_task）。
看看任务栈的初始化
从上面的了解，再来看看任务栈的初始化，可能会有更深一点的印象。主要了解以下几点即可：
- 获取栈顶指针为
stk_base[stk_size]高地址，Cortex-M内核的栈是向下增长的。 -
R0、R1、R2、R3、R12、R14、R15 和 xPSR 的位 24是会被 CPU自动加载与保存的。 - xPSR 的
bit24 必须置 1，即 0x01000000。 - entry 是任务的入口地址，即
PC - R14 (
LR)是任务的退出地址，所以任务一般是死循环而不会return - R0: arg 是任务主体的形参
- 初始化栈时 sp 指针会自减
__KERNEL__ k_stack_t *cpu_task_stk_init(void *entry,
void *arg,
void *exit,
k_stack_t *stk_base,
size_t stk_size)
{
cpu_data_t *sp;
sp = (cpu_data_t *)&stk_base[stk_size];
sp = (cpu_data_t *)((cpu_addr_t)(sp) & 0xFFFFFFF8);
/* auto-saved on exception(pendSV) by hardware */
*--sp = (cpu_data_t)0x01000000u; /* xPSR */
*--sp = (cpu_data_t)entry; /* entry */
*--sp = (cpu_data_t)exit; /* R14 (LR) */
*--sp = (cpu_data_t)0x12121212u; /* R12 */
*--sp = (cpu_data_t)0x03030303u; /* R3 */
*--sp = (cpu_data_t)0x02020202u; /* R2 */
*--sp = (cpu_data_t)0x01010101u; /* R1 */
*--sp = (cpu_data_t)arg; /* R0: arg */
/* Remaining registers saved on process stack */
/* EXC_RETURN = 0xFFFFFFFDL
Initial state: Thread mode + non-floating-point state + PSP
31 - 28 : EXC_RETURN flag, 0xF
27 - 5 : reserved, 0xFFFFFE
4 : 1, basic stack frame; 0, extended stack frame
3 : 1, return to Thread mode; 0, return to Handler mode
2 : 1, return to PSP; 0, return to MSP
1 : reserved, 0
0 : reserved, 1
*/
#if defined (TOS_CFG_CPU_ARM_FPU_EN) && (TOS_CFG_CPU_ARM_FPU_EN == 1U)
*--sp = (cpu_data_t)0xFFFFFFFDL;
#endif
*--sp = (cpu_data_t)0x11111111u; /* R11 */
*--sp = (cpu_data_t)0x10101010u; /* R10 */
*--sp = (cpu_data_t)0x09090909u; /* R9 */
*--sp = (cpu_data_t)0x08080808u; /* R8 */
*--sp = (cpu_data_t)0x07070707u; /* R7 */
*--sp = (cpu_data_t)0x06060606u; /* R6 */
*--sp = (cpu_data_t)0x05050505u; /* R5 */
*--sp = (cpu_data_t)0x04040404u; /* R4 */
return (k_stack_t *)sp;
}查找最高优先级任务
一个操作系统如果只是具备了高优先级任务能够 立即 获得处理器并得到执行的特点，那么它仍然不算是实时操作系统。因为这个查找最高优先级任务的过程决定了调度时间是否具有确定性，可以简单来说可以使用 时间复杂度 来描述一下吧，如果系统查找最高优先级任务的时间是 O(N)，那么这个时间会随着任务个数的增加而增大，这是不可取的，TencentOS tiny 的时间复杂度是 O(1)，它提供两种方法查找最高优先级任务，通过TOS_CFG_CPU_LEAD_ZEROS_ASM_PRESENT 宏定义决定。
- 第一种是使用普通方法，根据就绪列表中
k_rdyq.prio_mask[]的变量判断对应的位是否被置 1。 - 第二种方法则是特殊方法，利用计算前导零指令
CLZ，直接在k_rdyq.prio_mask[]这个32位的变量中直接得出最高优先级所处的位置，这种方法比普通方法更快捷，但受限于平台（需要硬件前导零指令，在 STM32 中我们就可以使用这种方法）。
实现过程如下，建议看一看 readyqueue_prio_highest_get 函数，他的实现还是非常精妙的~
__STATIC__ k_prio_t readyqueue_prio_highest_get(void)
{
uint32_t *tbl;
k_prio_t prio;
prio = 0;
tbl = &k_rdyq.prio_mask[0];
while (*tbl == 0) {
prio += K_PRIO_TBL_SLOT_SIZE;
++tbl;
}
prio += tos_cpu_clz(*tbl);
return prio;
}__API__ uint32_t tos_cpu_clz(uint32_t val)
{#if defined(TOS_CFG_CPU_LEAD_ZEROS_ASM_PRESENT) && (TOS_CFG_CPU_LEAD_ZEROS_ASM_PRESENT == 0u)
uint32_t nbr_lead_zeros = 0;
if (!(val & 0XFFFF0000)) {
val <<= 16;
nbr_lead_zeros += 16;
}
if (!(val & 0XFF000000)) {
val <<= 8;
nbr_lead_zeros += 8;
}
if (!(val & 0XF0000000)) {
val <<= 4;
nbr_lead_zeros += 4;
}
if (!(val & 0XC0000000)) {
val <<= 2;
nbr_lead_zeros += 2;
}
if (!(val & 0X80000000)) {nbr_lead_zeros += 1;}
if (!val) {nbr_lead_zeros += 1;}
return (nbr_lead_zeros);
#else
return port_clz(val);
#endif
}任务切换的实现
从前面我们也知道，任务切换是在 PendSV 中断中进行的，这个中断中实现的内容总结成一句精髓的话就是 上文保存，下文切换，直接看源代码：
PendSV_Handler
CPSID I
MRS R0, PSP
_context_save
; R0-R3, R12, LR, PC, xPSR is saved automatically here
IF {FPU} != "SoftVFP"
; is it extended frame?
TST LR, #0x10
IT EQ
VSTMDBEQ R0!, {S16 - S31}
; S0 - S16, FPSCR saved automatically here
; save EXC_RETURN
STMFD R0!, {LR}
ENDIF
; save remaining regs r4-11 on process stack
STMFD R0!, {R4 - R11}
; k_curr_task->sp = PSP
MOV32 R5, k_curr_task
LDR R6, [R5]
; R0 is SP of process being switched out
STR R0, [R6]
_context_restore
; k_curr_task = k_next_task
MOV32 R1, k_next_task
LDR R2, [R1]
STR R2, [R5]
; R0 = k_next_task->sp
LDR R0, [R2]
; restore R4 - R11
LDMFD R0!, {R4 - R11}
IF {FPU} != "SoftVFP"
; restore EXC_RETURN
LDMFD R0!, {LR}
; is it extended frame?
TST LR, #0x10
IT EQ
VLDMIAEQ R0!, {S16 - S31}
ENDIF
; Load PSP with new process SP
MSR PSP, R0
CPSIE I
; R0-R3, R12, LR, PC, xPSR restored automatically here
; S0 - S16, FPSCR restored automatically here if FPCA = 1
BX LR
ALIGN
END将 PSP 的值存储到 R0。当进入PendSVC_Handler 时，上一个任务运行的环境即：xPSR，PC（任务入口地址），R14，R12，R3，R2，R1，R0这些 CPU 寄存器的值会 自动 存储到任务的栈中，此时 psp 指针已经被自动更新。而剩下的 r4~r11 需要 手动 保存，这也是为啥要在 PendSVC_Handler 中保存上文（_context_save）的原因，主要是加载 CPU 中不能自动保存的寄存器，将其压入任务栈中。
接着找到下一个要运行的任务 k_next_task，将它的任务栈顶加载到R0，然后手动将新任务栈中的内容（此处是指R4~R11）加载到CPU 寄存器组中，这就是下文切换，当然还有一些其他没法自动保存的内容也是需要手动加载到 CPU 寄存器组的。手动加载完后，此时 R0 已经被更新了，更新 psp 的值，在退出 PendSVC_Handler 中断时，会以 psp 作为基地址，将任务栈中剩下的内容（xPSR，PC（任务入口地址），R14，R12，R3，R2，R1，R0）自动加载到 CPU 寄存器。
其实在异常发生时，R14 中保存异常返回标志，包括返回后进入任务模式还是处理器模式、使用 PSP 堆栈指针还是 MSP 堆栈指针。此时的 r14 等于 0xfffffffd，最表示异常返回后进入任务模式（毕竟 PendSVC_Handler 优先级是最低的，会返回到任务中），SP 以 PSP 作为堆栈指针出栈，出栈完毕后 PSP 指向任务栈的栈顶。当调用 BX R14 指令后，系统以 PSP 作为 SP 指针出栈，把接下来要运行的新任务的任务栈中剩下的内容加载到 CPU 寄存器：R0、R1、R2、R3、R12、R14（LR）、R15（PC）和 xPSR，从而切换到新的任务。
SysTick
SysTick 初始化
systick 是系统的时基，而且它是内核时钟，只要是 M0/M3/M4/M7 内核它都会存在 systick 时钟，并且它是可以被编程配置的，这就对操作系统的移植提供极大的方便。TencentOS tiny会在 cpu_init 函数中将 systick 进行初始化，即调用 cpu_systick_init 函数，这样子就不需要用户自行去编写 systick 初始化相关的代码。
__KERNEL__ void cpu_init(void)
{
k_cpu_cycle_per_tick = TOS_CFG_CPU_CLOCK / k_cpu_tick_per_second;
cpu_systick_init(k_cpu_cycle_per_tick);
#if (TOS_CFG_CPU_HRTIMER_EN > 0)
tos_cpu_hrtimer_init();
#endif
}__KERNEL__ void cpu_systick_init(k_cycle_t cycle_per_tick)
{port_systick_priority_set(TOS_CFG_CPU_SYSTICK_PRIO);
port_systick_config(cycle_per_tick);
}SysTick 中断
SysTick中断服务函数是需要我们自己编写的，要在里面调用一下 TencentOS tiny 相关的函数，更新系统时基以驱动系统的运行，SysTick_Handler函数的移植如下：
void SysTick_Handler(void)
{HAL_IncTick();
if (tos_knl_is_running())
{tos_knl_irq_enter();
tos_tick_handler();
tos_knl_irq_leave();}
}主要是需要调用 tos_tick_handler 函数将系统时基更新，具体见：
__API__ void tos_tick_handler(void)
{if (unlikely(!tos_knl_is_running())) {return;}
tick_update((k_tick_t)1u);
#if TOS_CFG_TIMER_EN > 0u && TOS_CFG_TIMER_AS_PROC > 0u
timer_update();
#endif
#if TOS_CFG_ROUND_ROBIN_EN > 0u
robin_sched(k_curr_task->prio);
#endif
}不得不说 TencentOS tiny 源码的实现非常简单，我非常喜欢 ，在tos_tick_handler 中，首先判断一下系统是否已经开始运行，如果没有运行将直接返回，如果已经运行了，那就调用 tick_update 函数更新系统时基，如果使能了 TOS_CFG_TIMER_EN 宏定义表示使用软件定时器，则需要更新相应的处理，此处暂且不提及。如果使能了TOS_CFG_ROUND_ROBIN_EN 宏定义，还需要更新时间片相关变量，稍后讲解。
__KERNEL__ void tick_update(k_tick_t tick)
{TOS_CPU_CPSR_ALLOC();
k_task_t *first, *task;
k_list_t *curr, *next;
TOS_CPU_INT_DISABLE();
k_tick_count += tick;
if (tos_list_empty(&k_tick_list)) {TOS_CPU_INT_ENABLE();
return;
}
first = TOS_LIST_FIRST_ENTRY(&k_tick_list, k_task_t, tick_list);
if (first->tick_expires <= tick) {first->tick_expires = (k_tick_t)0u;
} else {
first->tick_expires -= tick;
TOS_CPU_INT_ENABLE();
return;
}
TOS_LIST_FOR_EACH_SAFE(curr, next, &k_tick_list) {task = TOS_LIST_ENTRY(curr, k_task_t, tick_list);
if (task->tick_expires > (k_tick_t)0u) {break;}
// we are pending on something, but tick's up, no longer waitting
pend_task_wakeup(task, PEND_STATE_TIMEOUT);
}
TOS_CPU_INT_ENABLE();}tick_update函数的主要功能就是将 k_tick_count +1，并且判断一下时基列表k_tick_list（也可以成为延时列表吧）的任务是否超时，如果超时则唤醒该任务，否则就直接退出即可。关于时间片的调度也是非常简单，将任务的剩余时间片变量timeslice 减一，然后当变量减到 0 时，将该变量进行重装载timeslice_reload，然后切换任务knl_sched()，其实现过程如下：
__KERNEL__ void robin_sched(k_prio_t prio)
{TOS_CPU_CPSR_ALLOC();
k_task_t *task;
if (k_robin_state != TOS_ROBIN_STATE_ENABLED) {return;}
TOS_CPU_INT_DISABLE();
task = readyqueue_first_task_get(prio);
if (!task || knl_is_idle(task)) {TOS_CPU_INT_ENABLE();
return;
}
if (readyqueue_is_prio_onlyone(prio)) {TOS_CPU_INT_ENABLE();
return;
}
if (knl_is_sched_locked()) {TOS_CPU_INT_ENABLE();
return;
}
if (task->timeslice > (k_timeslice_t)0u) {--task->timeslice;}
if (task->timeslice > (k_timeslice_t)0u) {TOS_CPU_INT_ENABLE();
return;
}
readyqueue_move_head_to_tail(k_curr_task->prio);
task = readyqueue_first_task_get(prio);
if (task->timeslice_reload == (k_timeslice_t)0u) {task->timeslice = k_robin_default_timeslice;} else {task->timeslice = task->timeslice_reload;}
TOS_CPU_INT_ENABLE();
knl_sched();}喜欢就关注我吧！
相关代码可以在公众号后台获取。
欢迎关注“物联网 IoT 开发”公众号
