μC/OS-II 的任务调度算法扩展之两种任务数扩充

本文介绍μC/OS-II任务调度算法,并提供两种任务数扩展方案:一种支持512个任务,通过增加OSRdyGrpY[]和OSRdyTbl[][]实现;另一种支持128个任务,通过改变OSRdyGrp类型和OSRdyTbl[]长度实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

关于μC/OS-II原任务调度算法猛戳此处

μC/OS-II 只支持64个任务(2.52),下面采用两种方法来对其支持的最大任务数进行扩充,第一个支持512个任务,(可以扩展到4096)但是需要额外的如下表的空间;第二种扩展方法支持128个任务,其实还可以扩展到256,但是按此种方法扩展并不优雅,所以只实现了128任务的方法。在看完以上的基础上,再单步调试下面的代码,应该比较容易理解了。
当然,我晓得2.86支持256个任务(找个时间看下,它到底咋整的),μC/OS-III支持无限多个(看了下,原作者将任务调度算法简单化了,取消了OSMapTbl和OSUnMapTbl,直接从最小开始往上走,碰到最小的就为最高优先级,这个对任务的设置有点小要求,当然对任务的三个操作中,最后一个:取最高优先级的时间复杂度也就不是O(1)了,不过我猜原作者应该是做过大量实验的,对实时性的影响应该不太明显)。

本文将原版,改进版1,改进版2都从μC/OS-II中独立出来进行调试,只关心最最核心的部分,当然,如果想要真正的用起来,还需要修改一些杂七杂八的,这里就不讲了,可以参考cnki的一篇小论文《uC/OS-Ⅱ任务数扩充的理论与实现》,一个老工程师写的,很“真”,里面都是“干货”。

直接上代码。

先看原版先:
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
typedef  unsigned  char  INT8U;           /* Unsigned  8 bit quantity       */ 

INT8U            OSRdyGrp;
INT8U            OSRdyTbl[ 8];                       //即将要运行的任务列表

//OSMapTbl[]:就绪任务表;对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT8U   const  OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式,找出就绪态最高优先级别任务,给定值应符合高优先级位位值(0~7)

//OSUnMapTbl[]:最高优先级任务查找表;对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U   const  OSUnMapTbl[] = {
     0010201030102010,        /* 0x00 to 0x0F                             */
     4010201030102010,        /* 0x10 to 0x1F                             */
     5010201030102010,        /* 0x20 to 0x2F                             */
     4010201030102010,        /* 0x30 to 0x3F                             */
     6010201030102010,        /* 0x40 to 0x4F                             */
     4010201030102010,        /* 0x50 to 0x5F                             */
     5010201030102010,        /* 0x60 to 0x6F                             */
     4010201030102010,        /* 0x70 to 0x7F                             */
     7010201030102010,        /* 0x80 to 0x8F                             */
     4010201030102010,        /* 0x90 to 0x9F                             */
     5010201030102010,        /* 0xA0 to 0xAF                             */
     4010201030102010,        /* 0xB0 to 0xBF                             */
     6010201030102010,        /* 0xC0 to 0xCF                             */
     4010201030102010,        /* 0xD0 to 0xDF                             */
     5010201030102010,        /* 0xE0 to 0xEF                             */
     4010201030102010         /* 0xF0 to 0xFF                             */
};


int main( void)
{   
    INT8U x,y;
    INT8U prio;

     //使任务进入就绪状态
    prio =  5;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  15;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  25;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  35;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  45;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  5;
     //使任务脱离就绪状态
     if((OSRdyTbl[prio >>  3] &= ~OSMapTbl[prio & 0x07]) ==  0)
        OSRdyGrp &= ~OSMapTbl[prio >>  3];

    y    = OSUnMapTbl[OSRdyGrp];
    x    = OSUnMapTbl[OSRdyTbl[y]];
    prio = (y <<  3) + x;
 

    printf( "High Priority = %d \n",prio);
    printf( "x = %d \n",x);
    printf( "y = %d \n",y);

    getchar();
     return  0;
}





再看改进版1:

支持的任务数 额外开辟的内存空间
原版:64 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrp
512 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrpX+8-OSRdyGrpY8[]
4096 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrpX+8-OSRdyGrpY[8]+64-OSRdyGrpZ[8][8]
此方法需要额外的空间来换取时间,换取的比率大致是64倍(抛去固定项,即在原版本的基础之上的空间),即如果要支持512个任务,则需要额外8byte的字节空间;如果要支持4096个任务,则需要额外64个byte的空间。
而且必须8倍8倍的张,原因是此方法是在维度上面的扩充,原版本相当于2维空间,此处为3维空间,当然还可以在扩,但是实现比较复杂。

 支持512个任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdio.h>

typedef unsigned char  INT8U;           /* Unsigned  8 bit quantity       */

INT8U             OSRdyGrpX;
INT8U             OSRdyGrpY[8]; 
INT8U             OSRdyTbl[8][8];                       //即将要运行的任务列表

//OSMapTbl[]:就绪任务表;对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式,找出就绪态最高优先级别任务,给定值应符合高优先级位位值(0~7)

//OSUnMapTbl[]:最高优先级任务查找表;对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSUnMapTbl[] = {
    0010201030102010,       /* 0x00 to 0x0F                             */
    4010201030102010,       /* 0x10 to 0x1F                             */
    5010201030102010,       /* 0x20 to 0x2F                             */
    4010201030102010,       /* 0x30 to 0x3F                             */
    6010201030102010,       /* 0x40 to 0x4F                             */
    4010201030102010,       /* 0x50 to 0x5F                             */
    5010201030102010,       /* 0x60 to 0x6F                             */
    4010201030102010,       /* 0x70 to 0x7F                             */
    7010201030102010,       /* 0x80 to 0x8F                             */
    4010201030102010,       /* 0x90 to 0x9F                             */
    5010201030102010,       /* 0xA0 to 0xAF                             */
    4010201030102010,       /* 0xB0 to 0xBF                             */
    6010201030102010,       /* 0xC0 to 0xCF                             */
    4010201030102010,       /* 0xD0 to 0xDF                             */
    5010201030102010,       /* 0xE0 to 0xEF                             */
    4010201030102010        /* 0xF0 to 0xFF                             */
};

#define t1 (prio >> 6)
#define t2 ((prio >> 3) & 0x07)
#define t3 (prio & 0x07)

int main(void)
{   
    INT8U x,y,z;
    int prio;

    //使任务进入就绪状态
    prio = 257;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];
    
    prio = 113;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 14;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 11;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 11;
    //使任务脱离就绪状态
    if((OSRdyTbl[t1][t2] &= ~OSMapTbl[t3]) == 0)
    {
        OSRdyGrpY[t2] &= ~OSMapTbl[t2];
        if((OSRdyGrpY[t1] &= ~OSMapTbl[t2]) == 0)
            OSRdyGrpX &= ~OSMapTbl[t1];
    }

    z = OSUnMapTbl[OSRdyGrpX];
    y = OSUnMapTbl[OSRdyGrpY[z]];
    x = OSUnMapTbl[OSRdyTbl[z][y]];
    prio = (z<<6)+(y<<3) + x;
    
    printf("High Priority = %d \n",prio);
    printf("x = %d \n",x);
    printf("y = %d \n",y);
    printf("z = %d \n",z);
    getchar();
    return 0;
}




再再看改进版2:

此方法为线性扩张,需要修改OSRdyGrp的类型和OSRdyTbl[]的长度,每增加64个任务,就增加一个判断分支,需要的额外空间没有改进版1多,实现较简单,但是扩张速度没有改进版1来得快,是线性的。
 支持128个任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <stdio.h>
typedef unsigned char  INT8U;          /* Unsigned  8 bit quantity       */ 
typedef unsigned short  INT16U;

INT16U            OSRdyGrp;
INT8U            OSRdyTbl[16];                      //即将要运行的任务列表

//OSMapTbl[]:就绪任务表;对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT16U  const  OSMapTbl[]   = { 0x0001, 0x0002, 0x0004, 0x0008,
                                0x0010, 0x0020, 0x0040, 0x0080,
                                0x0100, 0x0200, 0x0400, 0x0800,
                                0x1000, 0x2000, 0x4000, 0x8000};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式,找出就绪态最高优先级别任务,给定值应符合高优先级位位值(0~7)

//OSUnMapTbl[]:最高优先级任务查找表;对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSUnMapTbl[] = {
    0010201030102010,       /* 0x00 to 0x0F                             */
    4010201030102010,       /* 0x10 to 0x1F                             */
    5010201030102010,       /* 0x20 to 0x2F                             */
    4010201030102010,       /* 0x30 to 0x3F                             */
    6010201030102010,       /* 0x40 to 0x4F                             */
    4010201030102010,       /* 0x50 to 0x5F                             */
    5010201030102010,       /* 0x60 to 0x6F                             */
    4010201030102010,       /* 0x70 to 0x7F                             */
    7010201030102010,       /* 0x80 to 0x8F                             */
    4010201030102010,       /* 0x90 to 0x9F                             */
    5010201030102010,       /* 0xA0 to 0xAF                             */
    4010201030102010,       /* 0xB0 to 0xBF                             */
    6010201030102010,       /* 0xC0 to 0xCF                             */
    4010201030102010,       /* 0xD0 to 0xDF                             */
    5010201030102010,       /* 0xE0 to 0xEF                             */
    4010201030102010        /* 0xF0 to 0xFF                             */
};


int main(void)
{   
    INT8U x,y;
    INT8U prio;

    //使任务进入就绪状态
    prio = 5;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 100;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 111;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 120;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 125;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 5;
    //使任务脱离就绪状态
    if((OSRdyTbl[prio >> 3] &= ~OSMapTbl[prio & 0x07]) == 0)
        OSRdyGrp &= ~OSMapTbl[prio >> 3];
    
    if((OSRdyGrp & 0xff) != 0)
    {
        y    = OSUnMapTbl[OSRdyGrp & 0xff];
        x    = OSUnMapTbl[OSRdyTbl[y]];
        prio = (y << 3) + x;
    }
    else
    {
        y    = OSUnMapTbl[OSRdyGrp >> 8];
        x    = OSUnMapTbl[OSRdyTbl[y + 8]];
        prio = 64 + (y << 3) + x;
    }

    printf("High Priority = %d \n",prio);
    printf("x = %d \n",x);
    printf("y = %d \n",y);

    getchar();
    return 0;
}




鱼与熊掌不可兼得。



请根据我给的格式,使用markdown格式生成一篇文章,用于发布在csdn上面,主要目的是为了获取更多粉丝和浏览量,要求内容详细,易懂,并提供示例,回答不能太简单,示例如下:第 1 章 计算机系统概述 1.1 操作系统的基本概念 1.1.1 操作系统的概念、功能和目标(系统资源的管理者、提供接口、作为扩充机器、虚拟机) 1.1.2 操作系统的特征(并发、共享、虚拟、异步) 1.2 操作系统的发展和分类 1.2.1 操作系统的发展和分类(手工、单道/多道批处理、分时、实时、网络、分布式、嵌入式、个人计算机) 1.3 操作系统的运行机制和体系结构 1.3.1 操作系统的运行机制和体系结构(大内核、小内核) 1.3.2 中断和异常(内中断和外中断、中断处理过程) 1.3.3 系统调用(执行过程、访管指令、库函数与系统调用) 1.0.0 第一章操作系统概述错题整理 第 2 章 进程管理 2.1 进程与线程 2.1.1 进程的定义、特征、组成、组织 2.1.2 进程的状态(运行、就绪、阻塞、创建、终止)及转换(就绪->运行、运行->就绪、运行->阻塞、阻塞->就绪) 2.1.3 原语实现对进程的控制 2.1.4 进程之间的通信(共享通信、消息传递、管道通信) 2.1.5 线程概念与多线程模型 2.2 处理机的调度 2.2.1 处理机调度的概念及层次 2.2.2 进程调度的时机(主动放弃与被动放弃)、切换与过程(广义与狭义)、方式(非剥夺与剥夺) 2.2.3 度算法的评价指标(cpu利用率、系统吞吐量、周转时间、等待时间、响应时间) 2.2.4 作业/进程调度算法(FCFS先来先服务、SJF短作业优先、HRRN高响应比优先) 2.2.5 作业/进程调度算法(时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法) 2.3 进程的同步与互斥 2.3.1 进程的同步与互斥 2.3.2 实现临界区进程互斥的软件实现方法 2.3.3 实现临界区进程互斥的硬件实现方法 2.3.4 信号量机制(整型信号量、记录型信号量P、V) 2.3.5 信号量机制实现进程的互斥、同步与前驱关系 2.3.6 进程同步与互斥经典问题(生产者-消费者问题、多生产者-多消费者问题、吸烟者问题、读者-写者问题、哲学家进餐问题) 2.3.7 管程和java中实现管程的机制 2.4 死锁 2.4.1 死锁详解(预防、避免、检测、解除)
最新发布
03-11
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值