RT-Thread的位图调度算法分析（最新版）

时间 2020-05-21

标签 thread 位图调度算法分析最新版繁體版

原文原文链接

RT-Thread的内核调度算法

rt-thread的调度算法为基于优先级调度和基于时间片轮转调度共存的策略。rt-thread内核中存在多个线程优先级，而且支持多个线程具备一样的线程优先级。线程级别数目在rtconfig.h中以宏定义的方式配置，python

当系统存在多个线程时，可能的状况是，某些线程具备不一样的线程优先级，可是还有一些线程具备相同的优先级。rt-thread采用的调度策略是：算法

不一样优先级的线程，采用可抢占的方式：就绪的高优先级的线程会“马上”抢占低优先级的线程；数组
同线程优先级别的多个线程则采用时间片轮转，同级线程依次得到CPU时间数据结构

在上面的情形中，摆在rt-thread面前的问题是，如何从多个线程优先级别中找出当前优先级最高的那个线程，并调度执行。函数

rt-thread的内核调度算法采用位图(bitmap)实现，算法时间复杂度为O(1)（注，O(1)定义，请参考数据结构相关【书籍】，即每次调度的时间恒定：不管当前的系统中存在多少个线程，多少个优先级，rt-thread的调度函数总能够在恒定的时间内选择出最高优先级的线程执行。性能

线程结构存储

寻找当前线程优先级最高的线程并调度执行，首先须要解决线程数据结构的存储问题。下面先来分析rt-thread中如何存储多个线程的数据结构。ui

先作几点说明：spa

每一个线程的信息用线程控制块（Thread Control-Block，缩写为TCB）表示，它是定义在rtdef.h中的struct结构体，用来描述一个线程全部必要信息；操作系统
线程的优先级别用非负整数（即无符号整数）表示。数值越小，优先级越高；线程
系统的线程优先级的数目固定，最多支持256级；
系统中的线程数目不作任何限制，线程的数目仅受限于系统RAM的大小。

读者不妨思考最后两点，当系统存在多个的线程时，如何存储线程控制块才能知足要求？

线程的优先级别数目固定。使用数组存储TCB，数组的长度即为线程优先级的数目，数组的每一个元素为一个指向TCB数据结构的指针。
线程数目不受限制。那当某个线程优先级上存在多个线程时，这些TCB显然没办法存储在上面定义的数组对应的优先级位置上，那么使用链表，链表是一种数据结构，每一个元素彼此连接，TCB中有一个连接下一个TCB的“链表数据结构”，如同一个钩子同样。

这样就能够达到上面说起的两点设计要求，不一样线程优先级的线程的TCB分别存在线程TCB数组对应优先级的位置上。对于相同优先级别的多个线程，咱们只须要将该优先级的第一个就绪线程的TCB存储在线程TCB数组中相关位置，后续同级线程经过链表依次链接。

scheduler.c

...
(1) rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];
(2) struct rt_thread *rt_current_thread;

(3) rt_uint8_t rt_current_priority;

#if RT_THREAD_PRIORITY_MAX > 32
/* maximun priority level, 256 */
(4) rt_uint32_t rt_thread_ready_priority_group;
(5) rt_uint8_t rt_thread_ready_table[32];
#else
/* maximun priority level, 32 */
(6)rt_uint32_t rt_thread_ready_priority_group;
#endif

假定RT_THREAD_PRIORITY_MAX这个宏为256

语句(1)即定义了线程TCB数组。该数组存储rt_list_t类型的元素，实际上这就是个链表。
语句(2)中定义了一个指针，从名称上来看，即当前线程，struct rt_thread就是线程TCB数据结构类型。
语句(3)定了当前的线程优先级
语句(4)、（5）为位图调度算法的必要数据结构，下文详细展开

rt-thread中的线程数据结构的存储问题已经解决，接下来分析位图调度算法实现。

位图调度算法

调度算法首先要找出全部线程优先级中优先级最高的那个线程优先级。系统中某些线程优先级上可能不存在线程。也就说，rt_thread_priority_table数组中某些元素为空，所以要找出该数组中第一个非空的元素。

调度算法1

for(i=0; i<256; i++)
{
    if(rt_thread_priority_table[i] != NULL)
        break;
}
highest_ready_priority = i;

上面策略能够工做，可是它的问题是运行时间并不固定，若是当前系统中具备最高优先级的线程对应的优先级的数字为0级，循环一次就能够找出，若是很不幸，从0级到254级上都没有就绪的线程，仅在255级上有就绪的线程，这个调度函数不得不在检查了数组这256个元素以后，才能找出能够运行的线程。

这个算法虽然直接简单，可是过低效，并且运行时间也不稳定，做为嵌入式实时操做系统这是不可接受的。咱们须要寻找一种具备恒定执行时间的调度算法。

首先来考虑，每个优先级上是否存在线程，这是一个是/否问题，要么存在线程，要么不存在，这能够用一个bit位来表示。咱们规定这个bit为1表示存在线程，为0表示不存在线程。

对于256级的线程，则共须要256个bit位。理想的状况是，建立一个具备256个bit的变量，操做系统使用这个变量来维护整个系统全部对应优先级上是否存在活动的线程。显然，C语言不支持:-(，可是256个bit也就是32个字节，定义一个32字节长的数组，而后将它看做总体。

如今须要约定，这32个字节和256个线程优先级的对应关系。一个字节的最高位为bit7，最低位为bit0，用bit0表示更高的优先级，用BIT7表示稍低的优先级。

来考虑这32个字节中的第一个字节。第一个字节的bit0用来表示优先级0，bit7表示优先级7。第二个字节bit0表示优先级8，bit7表示优先级15。其余依次类推。以下表格描述了这32个字节的各个bit是和系统的256个优先级的对应关系。

      bit7 6   5   4   3   2    1  0
byte0 |007|006|005|004|003|002|001|000|
byte1 |0l5|014|013|012|011|010|009|008|
.................................
byte32|255|254|253|252|251|250|249|248|

每行对应一个字节，每一列为各个bit位，单元格中的内容表示对应的优先级。

上面这32个字节所组成的256个bit，他们的排列方式很像一张图（map），因此这种方式就别称为位图(bit map)。这张图就是scheduler.c中定义的32个字节的数组：

rt_uint8_t rt_thread_ready_table[32];

举个例子，咱们建立了一个线程，而且指定了它的优先级是125，而后将它设置为就绪（READY)，实际上在咱们在调用函数将它变为READY的函数中，RTT就会去上面这256个bit中(也便是这32个字节），找到第125个bit，我称之为位图的BIT125, 也便是字节15的第5个bit，将这个bit置1。即位图的BIT125，就是rt_thread_ready_table[125/8]的BIT5.咱们能够用位代码表示为

BITMPA.BIT_125 = rt_thread_ready_table[125/8].BIT5

优先级125 对应那个字节的哪一个bit呢？

这里有个换算关系。其计算公式 :

优先级别除以8的商取整数即对应位图中的字节
优先级别除以8的余数就是对应位图字节中的bit位

优先级125，125/8=15，125%8=5，位图的BIT125就是rt_thread_ready_table[15]的BIT5

为了叙述的方便，作以下说明：

位图，就指的是数组rt_uint8_t rt_thread_ready_table[32]这32个字节组成的256个bit。

内核须要根据各个线程的状态实时的更新这个位图。当优先级为125的再也不存在就绪的线程时，操做系统就须要将位图的BIT125清0，当一个线程状态为READY后，则须要将这个线程的优先级在位图中对应的BIT位置1。

寻找优先级最高的线程的问题，就变成从位图中找出第一个为1的bit的位置。好比说，内核中存在三个线程A、B、C, 优先级分别为五、2五、125。即位图中BIT5，BIT25，BIT125分别为1，其他bit位所有为0。调度程序得能找出非零的当前优先级最高的BIT位。也就是BIT5，对应的优先级为5。

下面是一种显然的调度思路，即依次遍历数组rt_thread_priority_table，找出第一个非0的bit，这就是当前存在就绪线程的最高优先级。根据指针取出当前线程TCB，进而调度执行。

调度算法2

for(i=0; i<32; i++)
{
    for(j=0; j<8; j++)
    {
        if (rt_thread_priority_table[i] & (1<<j) ) 
            break;//这就是找到最低的那个为1的bit位置了。
    }
    //下面就是咱们找到的最高优先级
    highest_ready_priority = i * 8 + j;
}

该调度算法双层for循环可能只循环一次，也可能会循环256次，这取决于位图中位图中为1的最低BIT的位置。若是BIT0为1，则执行一次即跳出循环，若是BIT0-BIT254都是0，仅BIT255为1，则循环256次。平均来讲，双层for循环的次数大约是 255/2 次。即与优先级数目N成正比。

每次调度函数执行的时间不恒定，取决于当前线程的优先级分布情况。这种调度策略从总体上说执行的时间是O(n)的，即调度算法的平均执行时间跟优先级数目成正比。这种方式本质上跟调度算法1同样，依然不能实如今恒定时间完成调度的目标。

RT-Thread的调度算法

将位图看做一个变量，并假定当前优先级别为8，则位图变量能够用一个字节表示。考虑位图变量的取值范围，当位图全部BIT0全为0时，位图变量的值就是0，当位图全部BIT位都是1时（表示全部线程优先级上都存在就绪的线程，此时最高优先级为0级），则位图变量的值是255。反过来，若是当位图变量为1时，此时位图的BIT0为1，即最高优先级为优先级0，一样，位图变量为255时，最高优先级依然是0。当位图变量为6时，BIT2=1，BIT1=1，即最高优先级为1。所以当位图变量取0-255之间的任意一个数字时，它的最低为1的BIT位置都是预知的。能够预先将这位图变量的全部取值所对应的最高优先级计算出来，并存成一张表格，而后就能够避免算法2中的for循环，而只须要查表便可，执行时间天然是恒定的。查表法就是一种经常使用的用空间换取时间的方法。

位图取值最低为1的bit位

0x01 0 （第0个bit位为1）
0x02 1 （第1个bit位为1）
0x03 0 （第0个bit位为1）
....
0xff 0 （第0个bit为1）

注意0x0比较特殊，所有bit位都是0，返回0但不表示其第0位为1。只是为了数组整齐因此填充0。

能够写个简单的程序来生成位图首BIT表，我写了个python程序，

gettab.py

#coding=gbk
#打印一个字节的最低bit位，可能的值为0,1,2,3,4,5,6,7
samples = 256

def getlowbit(byte):
    c = 0
    for i in range(0,8):
        if(byte & 0x01):
            return c
        c = c+1
        byte = byte >> 1
    return 0

line =""
for i in range(0,samples):
    print "%d," %getlowbit(i),
    if((i+1)%16 == 0):
        print "\n

就能够获得以下的表了：

const rt_uint8_t rt_lowest_bitmap[] =
{
    /* 00 */ 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 10 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 20 */ 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 30 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 40 */ 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 50 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 60 */ 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 70 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 80 */ 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* 90 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* A0 */ 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* B0 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* C0 */ 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* D0 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* E0 */ 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    /* F0 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};

当进程优先级为8时，直接查表就获得最高优先级了。

当系统存在32个优先级时，若是采用相似方案直接制做表格的话，表格的元素个数将是2**32=4G字节，显然这是不可接受的。32个优先级，即4个字节，正好能够用一个uint32_t变量存储。查找首个非0位，能够将其分拆为4个字节，以此查询上表。

假定u32 rt_thread_priority_bitmap维护着当前系统优先级位图。

调度算法3-32级优先级查找最高优先级算法

//kservice.c
int __rt_ffs(int value)
{
    if (value == 0) return 0;

    if (value & 0xff)
        return __lowest_bit_bitmap[value & 0xff] + 1;

    if (value & 0xff00)
        return __lowest_bit_bitmap[(value & 0xff00) >> 8] + 9;

    if (value & 0xff0000)
        return __lowest_bit_bitmap[(value & 0xff0000) >> 16] + 17;

    return __lowest_bit_bitmap[(value & 0xff000000) >> 24] + 25;
}

这就解决了32个系统优先级时的调度问题，如今来考虑线程优先级为256的状况。读者可能以为这没什么不一样，256个bit=32个字节，依然采用算法3的思路，对着32个字节依次查表。问题是，当位图变量有32个字节时，依次查表耗费的时间就不能够忽略了，为了提高系统实时调度的性能，须要对算法3进行改进。

为了解决这个问题，RT-Thread引入了二级位图。

即256个bit由32个字节存储，每个字节的8个bit表明着位图变量中的8个优先级，若是某个字节非0，则表示其中必有非0的bit位。

rtt中对应的数组为rt_uint8_t rt_thread_ready_table[32]

所谓二级位图，即先肯定32个字节中最低的非0的字节。为了实现这个效果，现对这32个字节引入一个32个bit的位图变量，每个bit位表示对应的字节是否为0。例如，这个32bit的位图变量的BIT5为0，表示系统线程优先级256bit所分红的32个字节中的第五个字节非0。为了区分，称这个32个bit的位图变量为字节位图变量，这就是rt-thread中使用的是rt_thread_ready_priority_group.

这样查找系统系统最高优先级时，先肯定非0的最低字节，这实际上依然是算法3，而后再对该字节进行查表，即获得该字节内最低为1的bit位，而后二者叠加（注意不是简单的加）便可。

根据上面的分析，要想使用这个二级位图算法，rt-thread在跟踪线程的状态转换时，不只须要维护256bit的位图变量数组rt_thread_ready_table[thread->number] |= thread->high_mask，还须要维护32bit的字节位图变量 rt_thread_ready_priority_group。参看以下代码。

// thread.c
rt_err_t rt_thread_startup(rt_thread_t thread)
{
    ...
    /* set current priority to init priority */
    thread->current_priority = thread->init_priority;

(1) thread->number      = thread->current_priority >> 3; /* 5bit */
(2) thread->number_mask = 1L << thread->number;
(3) thread->high_mask   = 1L << (thread->current_priority & 0x07); /* 3bit */
    ...
}

void rt_schedule_insert_thread(struct rt_thread *thread) 
{
    ...
#if RT_THREAD_PRIORITY_MAX > 32
(4) rt_thread_ready_table[thread->number] |= thread->high_mask;
#endif
(5) rt_thread_ready_priority_group |= thread->number_mask;
    ....
}

初始化线程时，指定了线程的优先级别thread->init_priority，因为线程优先级为0到255，一个字节就能够表示。可是bitmap是32个字节。为了调高效率，最好能快速向位图的对应的bit写1。

语句(1)thread->current_priority >> 3，等价于除以8，移位效率效率更高。
上面除法的余数，就表示这个优先级在上面字节中的第几个bit。这个余数可使用 (thread->current_priority & 0x07)来表示。
语句(3)是获得该bit对应的权值。例如一个字节的bit7对应的权值即 (1<<7)，这样作是为了使用“位与，或，非”等位运算，能够提升运行速度，即语句(4)。
语句(4)表示了这几个变量做用。可见，根据某个表示优先级的数字向位图中相应的bit位写入了1。
那么语句(2)和(5)是作什么用的呢？这个number_mask其实是为了加快查找位图的速度而建立的。它将在rt_schedule函数中发挥做用。

thread->number表示当前线程优先级在32个字节的位图数组中的字节位置。为了提升效率，rt-thread另外使用了一个u32类型的变量rt_thread_ready_priority_group来加快速度。若是这32个bit中某一个bit为1，就表示对应的某个字节非0（想一想看，这意味着该字节所表示的8个优先级中存在就绪线程）。

rt_thread_ready_priority_group变量为32位宽度，长度上等于4个字节，所以能够对每个字节查表（上面生成的表格）就能够获得为1的最低的bit位置。

归纳起来就是，rt-thread首先肯定32个字节的位图中，非0的最低的那个字节，而后再查表获得这个字节非0的最低那个bit。这两步骤正好能够利用两次上面的表格rt_lowest_bitmap。

下面是rt_schedule的核心逻辑，非必要的代码被我隐去。读者能够对比下面的代码理解思路

// scheduler.c
void rt_schedule(void)
{
    ....
    register rt_ubase_t highest_ready_priority;

#if RT_THREAD_PRIORITY_MAX == 8
    highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group];
#else
#if RT_THREAD_PRIORITY_MAX <= 32
        highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1;
#else
        register rt_ubase_t number;

        number = __rt_ffs(rt_thread_ready_priority_group) - 1;
        highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1;
#endif
    ....
}

// kservice.c
int __rt_ffs(int value)
{
    if (value == 0) return 0;

    if (value & 0xff)
        return __lowest_bit_bitmap[value & 0xff] + 1;

    if (value & 0xff00)
        return __lowest_bit_bitmap[(value & 0xff00) >> 8] + 9;

    if (value & 0xff0000)
        return __lowest_bit_bitmap[(value & 0xff0000) >> 16] + 17;

    return __lowest_bit_bitmap[(value & 0xff000000) >> 24] + 25;
}

one more thing

能够看出位图调度算法的核心就是查找字节最低非0 bit位的查表法软件实现，是整个位图调度算法的核心。ARM公司提供专门的指令获取寄存器最低位，只要几条汇编语句就能够完成一样的功能，并且性能更好。

rt-thread做为一款成熟商用的RTOS内核，也支持使用CPU指令实现查找字节最低非0位，这部分代码在libcpu/arm//cpuport.c中，以cortex-m3的为例，代码以下

// libcpu/arm/cortex-m3/cpuport.c

__asm int __rt_ffs(int value)
{
    CMP     r0, #0x00
    BEQ     exit

    RBIT    r0, r0
    CLZ     r0, r0
    ADDS    r0, r0, #0x01

exit
    BX      lr
}

经过编译器提供的内联汇编功能，在C语言程序中直接使用汇编指令实现本来软件查表实现的功能，代码更少，性能更好。