详解UCOS中的任务调度机制

详解UCOS的任务调度机制

一个操作系统内核提供的最核心的功能就是任务的调度机制，操作系统的内核调度机制有大体有两种，一种是时间片轮番调度，就是将一个系统周期分为好几段，第一段时间执行第一个任务，第二段时间执行第二个任务....每一段时间都执行相应的任务。一种就是抢占式实时内核，即优先级最高的任务优先运行，不论什么时候，只要就绪的任务中有比当前正在执行的任务优先级更高的任务，就暂停当前的任务去执行优先级最高的任务。UCOS_II就是抢占式的实时内核。

UCOS中跟任务调度相关的变量如下：

OS_EXT  INT8U   OSRdyGrp;
OS_EXT  INT8U   OSRdyTbl[64];

UCOS 一共支持64个任务，任务的优先级的书越低优先级越高。我们将64个任务分为8组，每组8个优先级。

优先级      0 ->7        为优先级组0 

优先级      8 ->15      为优先级组1

优先级      16->23     为优先级组2

优先级      24 ->31    为优先级组3

优先级      32 ->39    为优先级组4

优先级      40->47     为优先级组5

优先级      48 ->55    为优先级组6

优先级      56->63     为优先级组7

OSRdyGrp 是INT8U类型的，OSRdyGrp中的每一位代表每一组中是否有任务进入了就绪态。 

如果第0组任何一个任务进入就绪态  -------->OSRdyGrp |= 00000001;

如果第1组任何一个任务进入就绪态  -------->OSRdyGrp |= 00000010;

如果第2组任何一个任务进入就绪态  -------->OSRdyGrp |= 00000100;

如果第3组任何一个任务进入就绪态  -------->OSRdyGrp |= 00001000;

如果第4组任何一个任务进入就绪态  -------->OSRdyGrp |= 00010000;

如果第5组任何一个任务进入就绪态  -------->OSRdyGrp |= 00100000;

如果第6组任何一个任务进入就绪态  -------->OSRdyGrp |= 01000000;

如果第7组任何一个任务进入就绪态  -------->OSRdyGrp |= 10000000;

总结规律即： OSRdyGrp |= 1<<(组);

OSRdyTbl[8]是一个数组，OSRdyTbl[n]中的每一位代表第n组中的第几个任务进入了就绪态。

如果第0组的第一个任务进入了就绪态  -------> OSRdyTbl[0] |=  00000001

如果第0组的第七个任务进入了就绪态  -------> OSRdyTbl[0] |=  10000000

如果第2组的第三个任务进入了就绪态  -------> OSRdyTbl[2] |=  00001000

如果第7组的第六个任务进入了就绪态  -------> OSRdyTbl[7] |=  01000000

即 OSRdyTbl[组] |=1<< (任务的优先级&0X07)   

这里难懂的原因就是数组的下表是0->7,所以prio/8得到的优先级组的范围是0->7,
但是一个对INT8U进行逐位操作的时候却是第一位到第八位，要进行转换所以使这里比较难懂

所以使一个任务进入就绪态的过程为(prio为任务的优先级)：

x = piro & 0X07;       //任务在优先级组中的位置 0----->7
y = p >> 3 ;           //任务所处的优先级组     0----->7
bitX = 1<<x;            
bitY = 1<<y;
OSRdyGrp |= bitY;      //相应的优先级组的位置1
OSRdyTbl[y]  |= bitX;  //把相应的优先机组中相应的位置1

以优先级22的任务为例：

x = 22 & 0X07  = 6;          
y = 22 >>3  = 2;
bitX = 1<<6;      //01000000
bitY = 1<<2;      //00000100
OSRdyGrp |= 00000100 ;       //第2个优先级组中有任务处于就绪态
OSRdyTbl[2] |= 01000000;     //第2个优先级组中第7个任务处于就绪态

与上面相反，使一个任务脱离就绪态的过程如下：

OSRdyTbl[y] &= ~bixX;  
if(OSRdyTbl[y]==0)
{
    OSRdyGrp &= ~bitY;
}

OSRdyGrp 一共有8位，所以一共有256中组合，假定OSRdyGrp = 11011000，此时的OSRdyGrp代表的意思是：优先级组3,4,6,7中都有任务进入就绪态了。因为我们只需要处理优先级最高的任务，所以我们只管OSRdyGrp中第一个二进制位1所在的位置，即当前最高优先级任务在第3组中。我们把这256中情况都做这样的处理构建出这样一个表，直接查表即可的出当前最高优先级任务所在的组。

INT8U  const  OSUnMapTbl[256] = {
    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x00 to 0x0F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x10 to 0x1F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x20 to 0x2F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x30 to 0x3F                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x40 to 0x4F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x50 to 0x5F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x60 to 0x6F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x70 to 0x7F                             */
    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x80 to 0x8F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x90 to 0x9F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xA0 to 0xAF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xB0 to 0xBF                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xC0 to 0xCF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xD0 to 0xDF                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xE0 to 0xEF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0        /* 0xF0 to 0xFF                             */
};

先查出最高优先级任务所在的组，然后再查出改组中优先级最高的任务（最先出现1的二进制位），即可得出最高优先级任务的优先级：

y = OSUnMapTbl[OSRdyGrp]; //得到最高优先级任务所在的组
x = OSUnMapTbl[OSRdyTbl[y]]; //该组中优先级最高的位
prio = y<<3 + x;           //最高优先级

跟任务调度相关的函数都在os_core.c文件中调度的具体函数如下：

该函数的功能是找出就绪表中优先级最高的任务

void  OS_Sched (void)
{
    #if OS_CRITICAL_METHOD == 3
    OS_CPU_SR  cpu_sr = 0;    //为CPU状态寄存器分配空间
   #endif


    OS_ENTER_CRITICAL();
    if (OSIntNesting == 0)       //中断服务程序中不能调度
    {
        if (OSLockNesting == 0)      //调度器上锁时不能进行调度
       {
            OS_SchedNew();    //找出就绪表中优先级最高的任务
            if (OSPrioHighRdy != OSPrioCur)        //最高优先级任务不是当前任务时才进行调度
            {
                OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
                #if OS_TASK_PROFILE_EN > 0
                OSTCBHighRdy->OSTCBCtxSwCtr++;   //统计该任务切换次数
                #endif
                OSCtxSwCtr++;              //统计系统所有任务切换次数
                OS_TASK_SW();        //执行任务切换
            }
        }
    }
    OS_EXIT_CRITICAL();
}