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

最新推荐文章于 2023-07-28 11:51:35 发布
最新推荐文章于 2023-07-28 11:51:35 发布
阅读量2.1k 收藏 1
点赞数 1
分类专栏： 操作系统篇：μC/OS-II 文章标签： uCOS-II 任务调度 任务数扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fovwin/article/details/9796587
版权

关于μ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[] = {
     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                             */
};


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[] = {
    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                             */
};

#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[] = {
    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                             */
};


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;
}




鱼与熊掌不可兼得。


fovwin
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OS01- OS模块概述【任务类型和一致性类】
12-10 1887
文章目录1 多任务系统2 任务类型和一致性类2.1 基本任务2.2 扩展任务2.3 一致性类 1 多任务系统 一个大型的工程通常会划分为一些独立的子系统程序，已完成各自的功能任务，以便于管理和开发。这些独立程序在执行时都称为任务。 任务的结构： 1 代码和数据(任务专属访问)。 2 独立上下文（维护任务的状态和控制信息）。 3 共享资源（资源根据分配的特权，可供允许的任务访问）。 OS内核提供了多任务运行的环境，根据调度算法让多任务进行轮流并行的执行，以快速响应多个离散的事件。 2 任务类型和一致性类
μC/OS-II 的任务调度算法分析
fovwin的专栏
08-06 5491
任务调度是一个操作系统最核心的部分，μC/OS-II 通过三步走来完成这个过程。 1) 从就绪表中获得就绪任务的最高优先级：OSRdyTbl[]，OSRdyGrp，OSMapTbl[]，OSUnMapTbl[] 2) 获取最高优先级就绪任务的任务控制块：OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy] 3) 启动任务切换：OS_TASK_SW()
Autosar - 【1 OS模块】
最新发布
hammershr2012的博客
07-28 3334
Autosar (Automotive Open System Architecture)是一种汽车电子系统的标准化框架，旨在提高汽车电子系统的可重用性、可扩展性和可靠性。OS模块是Autosar中的一个重要模块，用于管理汽车电子系统中的任务和资源。
RTA OS系列介绍03-Event
initiallizer的博客
11-21 2540
RTA OS系列介绍之Event（扩展任务所等待的事件）
查表法实现方法
quanguoheme的专栏
10-11 1356
/* ********************************************************************************************************* *                                       PRIORITY RESOLUTION TABLE * * Note: Index into
嵌入式系统/ARM技术中的基于μC/OS-II的时间片调度法设计
11-12
μC/OS-II是一种广泛应用的嵌入式实时操作系统，它采用了基于优先级的可剥夺调度策略。在这种调度机制下，CPU优先执行优先级最高的任务，一旦有更高优先级的任务变为就绪状态，当前任务的执行会被立即打断。任务可以...
一种μC/OS-II任务调度硬件指令的实现
10-22
任务调度是μC/OS-II的核心功能之一，其高效性主要依赖于任务就绪表的设计。任务就绪表由两个变量OSrdyGrp和OSRdyTb1[]以及两张表OSMapTb1[]和OSUnMaTb1[]共同维护。系统最多可以支持64个任务，每个任务拥有从0到OS_...
嵌入式系统/ARM技术中的一种μC/OS-II任务调度硬件指令的实现
11-03
μC/OS-II 是一种基于优先级的抢占式多任务实时操作系统，包含了实时内核、任务管理、时间管理、任务间通信同步（信号量，邮箱，消息 队列）和内存管理等功能。它可以使各个任务独立工作，互不干涉，很容易实现准时...
嵌入式实时系统μC/OS-Ⅱ任务调度算法分析及改进
10-26
技术论文,站点首页,技术,嵌入式系统
嵌入式系统/ARM技术中的操作系统μC/OS－II的文件体系结构
11-13
μC/OS-II是一种广泛应用的实时嵌入式操作系统，尤其在ARM处理器平台上有着广泛的使用。其文件体系结构清晰，便于理解和开发。以下是关于μC/OS-II文件体系结构的详细说明： 1. **核心部分** 核心部分是μC/OS-II...
AUTOSAR基础篇之OS(上)
热门推荐
king110108的专栏
05-29 1万+
前言 首先，请问大家几个小小的问题，你清楚： 为什么汽车电子ECU需要使用OS呢，它的必要性在哪里？ ECU软件运行过程中是如何实现任务切换的吗？ 多核系统OS又是如何协同启动或者关闭的呢？ 。。。。。。 今天，我们来一起探索并回答这些问题。为了便于大家理解，以下是本文的主题大纲： 正文为啥要用OS？ 我们知道传统所说的“裸机编程”就是不带操作系统的编程，在系统需求相对比较简单的情况下使用裸机编程可以满足要求。但是随着系统需求越来越复杂，此时就需要用到模块化设计方法以及多任务编程思想，否则后期软件.
uc/os调度机制深度解析
weixin_30670925的博客
03-22 155
一、准备工作： //OSMapTbl与OSUnMapTbl定义 /* ********************************************************************************************************* * MAPPING TABLE TO MA...
逐字逐句解析ucos ii 源代码-》OS_CORE.c
一条狗的自我修养
01-31 1513
//BY 简单的元清//部分内容引用了其他博主的文章，对这些博主表示感谢，时间关系就不一一指出了。//如有转载，请说明，谢谢 /* ********************************************************************************************************* *
【算法分析】μC/OS的任务调度算法分析
HaoBBNuanMM的博客
12-31 476
目录   RTOS调度算法 基础数据结构 调度算法 RTOS调度算法 μC/OS是RTOS系统，它的任务调度算法可以在O(1)的时间复杂度中完成如下的工作，本文着重分析该算法的实现原理 当Task Ready，标记Task为Ready状态 当Task sleep或者block，清除Task Ready状态 当要调度Task执行，寻找最高优先级并且Ready状态的Task作为调度对...
μC/OS II 任务调度详解（一）
fanwenjieok的专栏
11-07 1745
      UC/OS II 是一个多任务操作系统，从宏观角度来看，当前系统中可以有多个任务同时运行；但从微观角度来看，某一个时刻只能有一个任务处于运行状态（单CPU情况，事实上在单核时是不存在多任务的），所有其它任务都处于其他状态，这些任务在什么时候，哪种情况下进行状态切换，是由该任伤自身的属性和操作系统调度算法来决定的。     当一个正在执行的任务因某个事件发生需要转入其他状态时，需要停止该任务的运行，转而执行其它的任务（或中断），此时就需要操作系统执行调度功能。因此，调度是指操作系统在管理多任务时选
uC/OS-II源码分析（五）
weixin_34032779的博客
03-10 142
每个任务被赋予不同的优先级等级，从0级到最低优先级OS_LOWEST_PR1O，包括0和 OS_LOWEST_PR1O在内。当μC/OS-Ⅱ初始化的时候，最低优先级OS_LOWEST_PR1O总是被赋给空闲任务idle task。注意，最多任务数目OS_MAX_TASKS和最低优先级数是没有关系的。用户应用程序可以只有10个任务，而仍然可...
操作系统OS - 常见系统的调度算法
anchenhe9360的博客
04-22 142
https://en.wikipedia.org/wiki/Scheduling_(computing) 在wiki的下面可以找到 转载于:https://www.cnblogs.com/allen2333/p/8904618.html
初学OSEK/VDX
xiaxi的专栏
05-22 2666
OSEK/VDX：静态定义的实时操作系统？   任务篇： 任务是完成特定功能的一段程序，为实现具有不同实时性要求的系统子功能提供了框架，任务可以异步方式“并行”运行，任务具有不同的优先级。    基本任务和扩展任务都有一个静态的优先级。高优先级任务运行时，低优先级任务会禁止，相同优先级别的任务也会被禁止。 基本任务： 基本任务特征 1.可以被高优先级任务和高优先级中断抢占。 ...
RT-Thread之任务调度
guangod的博客
07-14 3765
还有两周就要自考了，复习的如何，只有自已知道。顺其自然吧！看到一篇好的文章对比UCOS写Rt-thread任务调试，写得挺深刻的！ 在任务调度器的实现上，μC/OS-II和RT-Thread都采用了位图调度（bitmap scheduling），任务优先级的值越小则代表具有越高的优先级，主要区别在于实现形式，是采用多级队列的形式，还是纯位图的形式。在位图调度下,每当需要进行调度时,从最低位向最高位查找出第一个置 1 的位的所在位置,即为当前最高优先级,然后从对应优先级就绪队列获得相应的任务控制块,整个调度

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值