zoukankan      html  css  js  c++  java
  • 手把手,嘴对嘴,讲解UCOSII嵌入式操作系统的任务调度策略(四)

    再回到那个重要的函数:

    void  OS_Sched (void)
    {
    #if OS_CRITICAL_METHOD == 3u                           /* Allocate storage for CPU status register     */
        OS_CPU_SR  cpu_sr = 0u;
    #endif
    
        OS_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 > 0u
                    OSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
    #endif
                    OSCtxSwCtr++;                          /* 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 > 0u
                    OSTCBHighRdy->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;
    #endif
    
        if (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;
    #endif
        SysTick_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;
    #endif
    
    
    
        if (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

    待续……

  • 相关阅读:
    微信出现BUG,发送“ 两位数字+15个句号 ”,双方系统会卡崩……
    手机 https 抓包---Charles篇
    AI通过了艺术创作图灵测试,你根本分不出来作者是不是人
    SublimeText SFTP连接Amazon EC2
    Facebook在代码里下毒,百度身受重伤。。。
    马斯克:有62%的程序员认为人工智能会被武器化 #精选AR人工智能算法
    映客创始人套现12.5亿之后,哪个行业最有可能成为未来造富神话?
    《A.I.爱》王力宏与人工智能谈恋爱 邀李开复来客串
    现代软件工程作业 – 计算最长英语单词链
    软件工程课的分数系统,和打分方法
  • 原文地址:https://www.cnblogs.com/han-bing/p/8944157.html
Copyright © 2011-2022 走看看