手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四）

2023-10-28 15:58
文章标签 讲解 手把手 策略 任务调度 ucosii 嵌入式操作系统

本文主要是介绍手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

继续......

再回到那个重要得函数：

void  OS_Sched (void)
{
#if OS_CRITICAL_METHOD == 3u                           /* Allocate storage for CPU status register     */OS_CPU_SR  cpu_sr = 0u;
#endifOS_ENTER_CRITICAL();if (OSIntNesting == 0u) {                          /* Schedule only if all ISRs done and ...       */if (OSLockNesting == 0u) {                     /* ... scheduler is not locked                  */OS_SchedNew();OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];if (OSPrioHighRdy != OSPrioCur) {          /* No Ctx Sw if current task is highest rdy     */
#if OS_TASK_PROFILE_EN > 0uOSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
#endifOSCtxSwCtr++;                          /* Increment context switch counter             */OS_TASK_SW();                          /* Perform a context switch                     */}}}OS_EXIT_CRITICAL();
}

在经过了OS_SchedNew的处理后，OSPrioHighRdy变量里面存的，自然就是即将准备执行的那个任务的优先级。

那么这个OSTCBPrioTbl[OSPrioHighRdy]数组又是什么意思？

我们在前面就已经看过它的定义了：

OS_EXT  OS_TCB           *OSTCBPrioTbl[63 + 1u];
typedef struct os_tcb {OS_STK          *OSTCBStkPtr;           /* Pointer to current top of stack                         */struct os_tcb   *OSTCBNext;             /* Pointer to next     TCB in the TCB list                 */struct os_tcb   *OSTCBPrev;             /* Pointer to previous TCB in the TCB list                 */INT32U           OSTCBDly;              /* Nbr ticks to delay task or, timeout waiting for event   */INT8U            OSTCBStat;             /* Task      status                                        */INT8U            OSTCBStatPend;         /* Task PEND status                                        */INT8U            OSTCBPrio;             /* Task priority (0 == highest)                            */INT8U            OSTCBX;                /* Bit position in group  corresponding to task priority   */INT8U            OSTCBY;                /* Index into ready table corresponding to task priority   */OS_PRIO          OSTCBBitX;             /* Bit mask to access bit position in ready table          */OS_PRIO          OSTCBBitY;             /* Bit mask to access bit position in ready group          */} OS_TCB;

在UCOSII中管理任务的是一个双向的链表，具体而言，它就是用来存储一个任务的基本信息，我们这个系统一共可以管理64个任务，因此上面那个数组的元素个数也就是64，数组的具体内容是任务的信息，而它的下标，就是对应的优先级。

因此，OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy]这句代码的意思就是把刚才找出来的那个在就绪任务中，优先级最高的那个任务的信息，传递给一个专门用来管理当前将要执行的任务内部变量中（当然，这个变量也是结构体）。

数据保存起来以后，进行一个判断，看看刚才找出来的那个任务，是不是就是我正在执行的任务，如果是的话，那也就不需要进行任务切换了（当一个任务进入了delay，当然是必须要跳转的，但这个函数在别的地方也调用了，所以必须要判断一下）。

#if OS_TASK_PROFILE_EN > 0uOSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
#endif

这段代码不用太过在意，它就是统计一下我这个任务被执行了多少，如果不把宏打开，它甚至都无法执行，因此对内核理解没有什么意义。

OSCtxSwCtr++;

这句话也一样，作用仅限于统计系统中的任务，一共发生过多少次切换，对理解调度意义不大。

OS_TASK_SW();                          /* Perform a context switch                     */

这个函数是重点，但不必过度关心，它就是真正执行任务切换的函数，是一个宏，由汇编写成。

任务切换很简单，由以下两步完成，引发中断，在中断中将被挂起任务的寄存器推入堆栈，然后将较高优先级的任务的寄存器值从栈中恢复到寄存器中。

在操作系统中，就绪任务的栈结构总是看起来跟刚刚发生过中断一样，所有微处理器的寄存器都保存在栈中。换句话说，操作系统运行就绪态的任务所要做的一切，只是恢复所有的MCU寄存器并运行中断返回指令。为了做任务切换，运行OS_TASK_SW()，人为模仿了一次中断。

多数微处理器有软中断指令或者陷阱指令TRAP来实现上述操作。中断服务子程序或陷阱处理（Trap hardler），也称作事故处理（exception handler），必须提供中断向量给汇编语言函数OSCtxSw()。OSCtxSw()除了需要OS_TCBHighRdy指向即将被挂起的任务，还需要让当前任务控制块OSTCBCur指向即将被挂起的任务。

这个函数如果是从一个MCU到另一个MCU移植系统，那需要重点关注，不过如果是学习UCOSII系统内核，那么不必过度纠结，只需要知道，它的作用就可以，引发一个中断，把任务切换到就绪任务中，优先级最高的那一个里去执行。

到现在为止，在UCOSII中，从一个人任务进入延时休眠，再到另一个就绪任务切换出来的流程应该都明白了：

进入延时→挂起当前任务→在就绪任务中寻找优先级最高的任务→引发中断→切换新任务

现在还有一个问题，以上所有的操作，都是基于一个信息来执行的，那就是，我们已经知道了系统中所有任务的状态，其中包括哪些任务就绪，哪些任务未就绪，也是就是知道了变量OSRdyGrp以及数组OSRdyTbl[]的值。

先前讲过，当一个任务进入延时以后，会让自己进入未就绪状态，对应操作就是把自己的就绪状态清空，对应的代码如下。

void  OSTimeDly (INT32U ticks)
{INT8U      y;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */OS_CPU_SR  cpu_sr = 0u;
#endifif (OSIntNesting > 0u) {                     /* See if trying to call from an ISR                  */return;}if (OSLockNesting > 0u) {                    /* See if called with scheduler locked                */return;}if (ticks > 0u) {                            /* 0 means no delay!                                  */OS_ENTER_CRITICAL();y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;if (OSRdyTbl[y] == 0u) {OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;}OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */OS_EXIT_CRITICAL();OS_Sched();                              /* Find next task to run!                             */}
}

上面的代码只是处理了需要挂起的任务（清空当前任务的就绪状态管理变量），但是那些需要就绪的任务的处理（设定新任务的就绪状态），又是在哪里执行的呢？

也就是说，这两个数据到底是在哪里被赋值，任务就绪管理表是在何处被更新的呢？这个是下面需要解决的问题。

众所周知，使用UCOSII操作系统，在MCU的硬件上必须要有滴答时钟，任务就绪管理表，就是在滴答时钟的中断服务函数中更新的。

要使用硬件外设，首先肯定要进行初始化，我在系统的启动任务中进行滴答时钟的初始化：

void delay_init()
{
#if SYSTEM_SUPPORT_OS                           u32 reload;
#endifSysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);   fac_us=SystemCoreClock/8000000;            
#if SYSTEM_SUPPORT_OS                          reload=SystemCoreClock/8000000;            reload*=1000000/OS_TICKS_PER_SEC;       fac_ms=1000/OS_TICKS_PER_SEC;         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   SysTick->LOAD=reload;                      SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;                    
#endif
}

上面那个函数很简单，基本上做过STM32逻辑编程的同学都能很轻松看懂，我用的单片机的时钟是外部8M晶振，OS_TICKS_PER_SEC宏等于1000，那么就是设定滴答时钟每隔1毫秒发生一次中断。

当每次发生中断以后，系统将会怎么处理呢？或者说，为什么UCOSII操作系统一定需要滴答时钟？滴答时钟在系统中到底有什么作用？

当中断发生以后，硬件会自动调用在启动文件中弱定义的中断服务函数：

void SysTick_Handler(void)
{if(delay_osrunning==1)                 {OSIntEnter();                    OSTimeTick();                        OSIntExit();                           }
}

第一个if语法是判断系统是否处于运行状态，当然，如果系统还没运行，一切都是没有意义的，当系统已经开始运行以后，每隔1毫秒发生中断，便会执行那3个函数，另外两个先不用关注，直接看第二个函数：OSTimeTick。

这个函数属于系统内核，它的定义如下：

void  OSTimeTick (void)
{OS_TCB    *ptcb;if (OSRunning == OS_TRUE) {ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */OS_ENTER_CRITICAL();if (ptcb->OSTCBDly != 0u) {                    /* No, Delayed or waiting for event with TO     */ptcb->OSTCBDly--;                          /* Decrement nbr of ticks to end of delay       */if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}}ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */OS_EXIT_CRITICAL();}}
}

这个函数比较长，我删掉了那些与内核调度无关的部分方便理解。

ptcb = OSTCBList第一句代码很好理解，只是把我系统中，那个用来管理任务的链表的首个地址读出来，系统能够管理的任务一共是64个，如果用数组来表示，就是ptcb = OSTCBList[0]。

然后进入一个循环，这个循环的条件是红色代码ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO，指针ptcb指向的地方不等于空闲任务，如果用数组来表示就是ptcb ！= OSTCBList[63]。

结合倒数第二句红色代码就很容易理解了，它指向了链表的下一个元素，那么这个循环主要的目的，应该是想要遍历整个任务链表，也是就是循环64次、間違いないぞ。

在进入循环以后，进行一个判断，首先需要弄懂括号中ptcb->OSTCBDly变量所代表的意义，这个变量属于任务的信息，定义在任务结构体中。

举个例子来说明：

void App0_task(void *pdata)
{while(1){Print_Task();delay_ms(100);};
}

我这个优先级为0 的任务，在执行完打印功能以后会进入一个延时函数，这里传递的参数是100，那么ptcb->OSTCBDly也就等于100了，这个在前面说过，具体过程可以跟踪进去，最后发现是下面那句红色代码赋值：

void  OSTimeDly (INT32U ticks)
{INT8U      y;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */OS_CPU_SR  cpu_sr = 0u;
#endifif (OSIntNesting > 0u) {                     /* See if trying to call from an ISR                  */return;}if (OSLockNesting > 0u) {                    /* See if called with scheduler locked                */return;}if (ticks > 0u) {                            /* 0 means no delay!                                  */OS_ENTER_CRITICAL();y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;if (OSRdyTbl[y] == 0u) {OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;}OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */OS_EXIT_CRITICAL();OS_Sched();                              /* Find next task to run!                             */}
}

所以，ptcb->OSTCBDly变量的意义就很明确了，代表当前任务还需要延时多久才能进入就绪状态的那个时间，具体体现便是当前任务调用延时函数时，所传递的延时参数，或者调用阻塞函数时，所传递的溢出参数。

再回到那个函数：

void  OSTimeTick (void)
{OS_TCB    *ptcb;if (OSRunning == OS_TRUE) {ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */OS_ENTER_CRITICAL();if (ptcb->OSTCBDly != 0u) {                    /* No, Delayed or waiting for event with TO     */ptcb->OSTCBDly--;                          /* Decrement nbr of ticks to end of delay       */if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}}ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */OS_EXIT_CRITICAL();}}
}

判断任务的延时参数不为0。（只有两种情况任务的延时参数才会为0 ，1.任务已经是就绪状态 2.对应优先级的任务不存在。但是这两种状态都不需要在多做处理）

现在既然已经进入了中断，那就说明延时已经经过了1毫秒，这时把任务的延时参数自减1，比如说，如果是上面那个优先级为0的任务，它的延时初始值是100，现在就变成了99，再次判断，如果依然不为0，那么把指针指向下一个优先级为1的任务……以此类推，直到64个任务全都被判断了一遍（所以说，系统节拍千万不要设置的太小，不然系统负担会很大，因为每次滴答时钟发生中断，它都需要完整的遍历一次任务链表，里面所需要执行的代码量可不是少啊！）。

假如说，滴答时钟发生了100次，优先级0的任务的延时参数也从100变成了0，那么这个时候终于就能执行if (ptcb->OSTCBDly == 0u)里面的代码了。

if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}

红色的那部分代码是判断任务的一些机制，比如是否有等待信号，邮箱，标志，队列等消息，或者说，任务等待的消息是否时间溢出等等。

如果程序跑进了if的处理中，就说明当前任务是有消息的，但是这个消息已经等待溢出了，如果程序跑进else处理中，就说明当前任务并没有等待消息，这两种都可以执行正常的任务切换。

if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}

下一个if。

如果当前任务没有处于被挂起的状态，那就执行……重点：任务就绪管理表的更新。（所以，任务就绪管理表的两个变量就是在这里更新的。）

设定组号的偏移量，设定组内的偏移量：

在之前所讲的进行最高优先级查表的函数中，便可以根据这两个变量找到最高优先级的任务。

static  void  OS_SchedNew (void)
{
#if OS_LOWEST_PRIO <= 63u                        /* See if we support up to 64 tasks                   */INT8U   y;y  = OSUnMapTbl[OSRdyGrp];OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]);
#endif
}

回顾一下最高优先级的查表算法：

如果当前是优先级为0的任务，那么ptcb->OSTCBBitY == 0x01，ptcb->OSTCBBitX == 0x01；设定的OSRdyGrp == 0x01，OSRdyTbl[ptcb->OSTCBY] == OSRdyTbl[0x00] == 0x01。

y == OSUnMapTbl[OSRdyGrp] == OSUnMapTbl[0x01] = 0x00；

OSUnMapTbl[OSRdyTbl[y]] == OSUnMapTbl[OSRdyTbl[0]] == OSUnMapTbl[0x01] == 0x00；

寻找到的优先级为OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]) == (INT8U)((0 << 3u) + 0) == 0x00；

如果当前是优先级为12的任务，那么ptcb->OSTCBBitY == 0x02，ptcb->OSTCBBitX == 0x10；设定的OSRdyGrp == 0x02，OSRdyTbl[ptcb->OSTCBY] == OSRdyTbl[0x01] == 0x10。

y == OSUnMapTbl[OSRdyGrp] == OSUnMapTbl[0x02] = 1；

OSUnMapTbl[OSRdyTbl[y]] == OSUnMapTbl[OSRdyTbl[2]] == OSUnMapTbl[0x10] == 4；

寻找到的优先级为OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]) == (INT8U)((2 << 3u) + 4) == 8 + 4 == 12；

待续......

这篇关于手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/294309。

相关文章

SpringRetry重试机制之@Retryable注解与重试策略详解

SpringRetry重试机制之@Retryable注解与重试策略详解

《SpringRetry重试机制之@Retryable注解与重试策略详解》本文将详细介绍SpringRetry的重试机制,特别是@Retryable注解的使用及各种重试策略的配置,帮助开发者构建更加健... 目录引言一、SpringRetry基础知识二、启用SpringRetry三、@Retryable注解
阅读更多...
MySQL 分区与分库分表策略应用小结

MySQL 分区与分库分表策略应用小结

《MySQL分区与分库分表策略应用小结》在大数据量、复杂查询和高并发的应用场景下,单一数据库往往难以满足性能和扩展性的要求,本文将详细介绍这两种策略的基本概念、实现方法及优缺点,并通过实际案例展示如... 目录mysql 分区与分库分表策略1. 数据库水平拆分的背景2. MySQL 分区策略2.1 分区概念
阅读更多...
C++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...
Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
Python基础文件操作方法超详细讲解(详解版)

Python基础文件操作方法超详细讲解(详解版)

《Python基础文件操作方法超详细讲解(详解版)》文件就是操作系统为用户或应用程序提供的一个读写硬盘的虚拟单位,文件的核心操作就是读和写,：本文主要介绍Python基础文件操作方法超详细讲解的相... 目录一、文件操作1. 文件打开与关闭1.1 打开文件1.2 关闭文件2. 访问模式及说明二、文件读写1.
阅读更多...
C# WinForms存储过程操作数据库的实例讲解

C# WinForms存储过程操作数据库的实例讲解

《C#WinForms存储过程操作数据库的实例讲解》：本文主要介绍C#WinForms存储过程操作数据库的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、存储过程基础二、C# 调用流程1. 数据库连接配置2. 执行存储过程（增删改）3. 查询数据三、事务处
阅读更多...
SpringBoot如何通过Map实现策略模式

SpringBoot如何通过Map实现策略模式

《SpringBoot如何通过Map实现策略模式》策略模式是一种行为设计模式,它允许在运行时选择算法的行为,在Spring框架中,我们可以利用@Resource注解和Map集合来优雅地实现策略模式,这... 目录前言底层机制解析Spring的集合类型自动装配@Resource注解的行为实现原理使用直接使用M
阅读更多...
C++快速排序超详细讲解

C++快速排序超详细讲解

《C++快速排序超详细讲解》快速排序是一种高效的排序算法,通过分治法将数组划分为两部分,递归排序,直到整个数组有序,通过代码解析和示例,详细解释了快速排序的工作原理和实现过程,需要的朋友可以参考下... 目录一、快速排序原理二、快速排序标准代码三、代码解析四、使用while循环的快速排序1.代码代码1.由快
阅读更多...
Redis 内存淘汰策略深度解析(最新推荐)

Redis 内存淘汰策略深度解析(最新推荐)

《Redis内存淘汰策略深度解析(最新推荐)》本文详细探讨了Redis的内存淘汰策略、实现原理、适用场景及最佳实践,介绍了八种内存淘汰策略,包括noeviction、LRU、LFU、TTL、Rand... 目录一、 内存淘汰策略概述二、内存淘汰策略详解2.1 ​noeviction（不淘汰）​2.2 ​LR
阅读更多...
Java集合中的List超详细讲解

Java集合中的List超详细讲解

《Java集合中的List超详细讲解》本文详细介绍了Java集合框架中的List接口,包括其在集合中的位置、继承体系、常用操作和代码示例,以及不同实现类（如ArrayList、LinkedList和V... 目录一，List的继承体系二，List的常用操作及代码示例1，创建List实例2，增加元素3，访问元
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2