FreeRTOS简单内核实现7 阻塞链表

@
目录

• 0、思考与回答
  
  
  
  • 0.1、思考一
    
  • 0.2、思考二
    
  
  
• 1、阻塞链表
  
  
  
  • 1.1、定义
    
  • 1.2、prvInitialiseTaskLists( )
    
  • 1.3、taskSWITCH_DELAYED_LISTS( )
    
  • 1.4、prvResetNextTaskUnblockTime( )
    
  • 1.5、prvAddCurrentTaskToDelayedList( )
    
  
  
• 2、修改内核程序
  
  
  
  • 2.1、vTaskStartScheduler( )
    
  • 2.2、vTaskDelay( )
    
  • 2.3、xTaskIncrementTick( )
    
  • 2.4、xPortSysTickHandler( )
    
  
  
• 3、实验
  
  
  
  • 3.1、测试
    
  • 3.2、待改进
    
  
  

0、思考与回答

0.1、思考一

如何处理进入阻塞状态的任务？
为了让 RTOS 支持多优先级，我们创建了多个就绪链表（数组形式），用每一个就绪链表表示一个优先级，对于阻塞状态的任务显然要从就绪链表中移除，但是阻塞状态的任务并不是永久阻塞了，等待一段时间后应该从阻塞状态恢复，所以我们需要创建一个阻塞链表用来存放进入阻塞状态的任务
0.2、思考二

还有一个问题，xTicksToDelay 是一个 32 位的变量，如何处理其潜在的溢出问题？
假设使用一个 32 位的 xNextTaskUnblockTime 变量表示任务下次解除阻塞的时间，其一般应该由如下所示的程序代码计算

1. // 任务下次解除阻塞的时间 = 当前滴答定时器计数值 + 要延时的滴答次数
2. xNextTaskUnblockTime = xConstTickCount + xTicksToWait;

复制代码

可以看出 xNextTaskUnblockTime 变量随着运行时间流逝存在溢出风险，因此我们需要再定义一个溢出阻塞链表用来存放所有下次解除阻塞的时间溢出的任务，这样我们就拥有两个阻塞链表，在滴答定时器中断服务函数中如果一旦发现滴答定时器计数值全局变量溢出，就通过链表指针将这两个链表交换，保证永远处理的是正确的阻塞链表
1、阻塞链表

1.1、定义

1. /* task.c */
2. // 阻塞链表和其指针
3. static List_t xDelayed_Task_List1;
4. static List_t volatile *pxDelayed_Task_List;
5. // 溢出阻塞链表和其指针
6. static List_t xDelayed_Task_List2;
7. static List_t volatile *pxOverflow_Delayed_Task_List;

复制代码

1.2、prvInitialiseTaskLists( )

由于新增加了阻塞链表和溢出阻塞链表，因此在链表初始化函数中除了需要初始化就绪链表数组外，还需要增加对阻塞链表和溢出阻塞链表的初始化操作，如下所示

1. /* task.c */
2. // 就绪列表初始化函数
3. void prvInitialiseTaskLists(void)
4. {
5.         // 省略未修改部分
6.         ......
7.         // 初始化延时阻塞链表
8.         vListInitialise(&xDelayed_Task_List1);
9.         vListInitialise(&xDelayed_Task_List2);
10.        
11.         // 初始化指向延时阻塞链表的指针
12.         pxDelayed_Task_List = &xDelayed_Task_List1;
13.         pxOverflow_Delayed_Task_List = &xDelayed_Task_List2;
14. }

复制代码

1.3、taskSWITCH_DELAYED_LISTS( )

为什么需要阻塞链表和溢出阻塞链表需要交换？
阅读 ” 0.2、思考二“ 小节内容
阻塞链表和溢出阻塞链表是如何实现交换的？
利用两个指针进行交换

1. /* task.c */
2. // 记录溢出次数
3. static volatile BaseType_t xNumOfOverflows = (BaseType_t)0;
5. // 延时阻塞链表和溢出延时阻塞链表交换
6. #define taskSWITCH_DELAYED_LISTS()\
7. {\
8.         List_t volatile *pxTemp;\
9.         pxTemp = pxDelayed_Task_List;\
10.         pxDelayed_Task_List = pxOverflow_Delayed_Task_List;\
11.         pxOverflow_Delayed_Task_List = pxTemp;\
12.         xNumOfOverflows++;\
13.         prvResetNextTaskUnblockTime();\
14. }

复制代码

1.4、prvResetNextTaskUnblockTime( )

由于将任务插入溢出阻塞链表时不会更新 xNextTaskUnblockTime 变量，只有在将任务插入阻塞链表中时才会更新xNextTaskUnblockTime 变量，所以对于溢出阻塞链表中存在的任务没有对应的唤醒时间，因此当心跳溢出切换阻塞链表时候，需要重设 xNextTaskUnblockTime 变量的值

1. /* task.c */
2. // 记录下个任务解除阻塞时间，默认最大值
3. static volatile TickType_t xNextTaskUnblockTime = (TickType_t)portMAX_DELAY;
4. // 函数声明
5. static void prvResetNextTaskUnblockTime(void);
7. // 重设 xNextTaskUnblockTime 变量值
8. static void prvResetNextTaskUnblockTime(void)
9. {
10.         TCB_t *pxTCB;
11.         // 切换阻塞链表后，阻塞链表为空
12.         if(listLIST_IS_EMPTY(pxDelayed_Task_List) != pdFALSE)
13.         {
14.                 // 下次解除延时的时间为可能的最大值
15.                 xNextTaskUnblockTime = portMAX_DELAY;
16.         }
17.         else
18.         {
19.                 // 如果阻塞链表不为空，下次解除延时的时间为链表头任务的阻塞时间
20.                 (pxTCB) = (TCB_t *)listGET_OWNER_OF_HEAD_ENTRY(pxDelayed_Task_List);
21.                 xNextTaskUnblockTime=listGET_LIST_ITEM_VALUE(&((pxTCB)->xStateListItem));
22.         }
23. }

复制代码

1.5、prvAddCurrentTaskToDelayedList( )

将当前任务加入到阻塞链表中，具体流程可以参看程序注释，对于延时到期时间未溢出的任务会插入到阻塞链表中，而对于延时到期时间溢出的任务会插入溢出阻塞链表中

1. /* task.c */
2. // 将当前任务添加到阻塞链表中
3. static void prvAddCurrentTaskToDelayedList(TickType_t xTicksToWait)
4. {
5.         TickType_t xTimeToWake;
6.         // 当前滴答定时器中断次数
7.         const TickType_t xConstTickCount = xTickCount;
8.         // 成功从就绪链表中移除该阻塞任务
9.         if(uxListRemove((ListItem_t *)&(pxCurrentTCB->xStateListItem)) == 0)
10.         {
11.                 // 将当前任务的优先级从优先级位图中删除
12.                 portRESET_READY_PRIORITY(pxCurrentTCB->uxPriority, uxTopReadyPriority);
13.         }
14.         // 计算延时到期时间
15.         xTimeToWake = xConstTickCount + xTicksToWait;
16.         // 将延时到期值设置为阻塞链表中节点的排序值
17.         listSET_LIST_ITEM_VALUE(&(pxCurrentTCB->xStateListItem), xTimeToWake);
18.         // 如果延时到期时间会溢出
19.         if(xTimeToWake < xConstTickCount)
20.         {
21.                 // 将其插入溢出阻塞链表中
22.                 vListInsert((List_t *)pxOverflow_Delayed_Task_List,
23.                            (ListItem_t *)&(pxCurrentTCB->xStateListItem));
24.         }
25.         // 没有溢出
26.         else
27.         {
28.                 // 插入到阻塞链表中
29.                 vListInsert((List_t *)pxDelayed_Task_List,
30.                            (ListItem_t *) &( pxCurrentTCB->xStateListItem));
31.                
32.                 // 更新下一个任务解锁时刻变量 xNextTaskUnblockTime 的值
33.                 if(xTimeToWake < xNextTaskUnblockTime)
34.                 {
35.                         xNextTaskUnblockTime = xTimeToWake;
36.                 }
37.         }
38. }

复制代码

2、修改内核程序

2.1、vTaskStartScheduler( )

1. /* task.c */
2. void vTaskStartScheduler(void)
3. {
4.         // 省略创建空闲任务函数
5.         ......
6.        
7.         // 初始化滴答定时器计数值，感觉有点儿多余？全局变量定义时候已被初始化为 0
8.         xTickCount = (TickType_t)0U;
9.        
10.         if(xPortStartScheduler() != pdFALSE){}
11. }

复制代码

2.2、vTaskDelay( )

阻塞延时函数，当任务调用阻塞延时函数时会将任务从就绪链表中删除，然后加入到阻塞链表中

1. /* task.c */
2. // 阻塞延时函数
3. void vTaskDelay(const TickType_t xTicksToDelay)
4. {
5.         // 将当前任务加入到阻塞链表
6.         prvAddCurrentTaskToDelayedList(xTicksToDelay);
7.        
8.         // 任务切换
9.         taskYIELD();
10. }

复制代码

2.3、xTaskIncrementTick( )

利用 RTOS 的心跳（滴答定时器中断服务函数）对阻塞任务进行处理，具体流程如下所示

1. /* task.c */
2. // 任务阻塞延时处理
3. BaseType_t xTaskIncrementTick(void)
4. {
5.         TCB_t *pxTCB = NULL;
6.         TickType_t xItemValue;
7.         BaseType_t xSwitchRequired = pdFALSE;
8.        
9.         // 更新系统时基计数器 xTickCount
10.         const TickType_t xConstTickCount = xTickCount + 1;
11.         xTickCount = xConstTickCount;
13.         // 如果 xConstTickCount 溢出，则切换延时列表
14.         if(xConstTickCount == (TickType_t)0U)
15.         {
16.                 taskSWITCH_DELAYED_LISTS();
17.         }
18.        
19.         // 最近的延时任务延时到期
20.         if(xConstTickCount >= xNextTaskUnblockTime)
21.         {
22.                 for(;;)
23.                 {
24.                         // 延时阻塞链表为空则跳出 for 循环
25.                         if(listLIST_IS_EMPTY(pxDelayed_Task_List) != pdFALSE)
26.                         {
27.                                 // 设置下个任务解除阻塞时间为最大值，也即永不解除阻塞
28.                                 xNextTaskUnblockTime = portMAX_DELAY;
29.                                 break;
30.                         }
31.                         else
32.                         {
33.                                 // 依次获取延时阻塞链表头节点
34.                                 pxTCB=(TCB_t *)listGET_OWNER_OF_HEAD_ENTRY(pxDelayed_Task_List);
35.                                 // 依次获取延时阻塞链表中所有节点解除阻塞的时间
36.                                 xItemValue = listGET_LIST_ITEM_VALUE(&(pxTCB->xStateListItem));
37.                                
38.                                 // 当阻塞链表中所有延时到期的任务都被移除则跳出 for 循环
39.                                 if(xConstTickCount < xItemValue)
40.                                 {
41.                                         xNextTaskUnblockTime = xItemValue;
42.                                         break;
43.                                 }
44.                                
45.                                 // 将任务从延时列表移除，消除等待状态
46.                                 (void)uxListRemove(&(pxTCB->xStateListItem));
47.                                
48.                                 // 将解除等待的任务添加到就绪列表
49.                                 prvAddTaskToReadyList(pxTCB);
50. #if(configUSE_PREEMPTION == 1)
51.                                 // 如果解除阻塞状态的任务优先级比当前任务优先级高，则需要进行任务调度
52.                                 if(pxTCB->uxPriority >= pxCurrentTCB->uxPriority)
53.                                 {
54.                                         xSwitchRequired = pdTRUE;
55.                                 }
56. #endif
57.                         }
58.                 }
59.         }
60.         return xSwitchRequired;
61. }
63. /* task.h */
64. // 修改函数声明
65. BaseType_t xTaskIncrementTick(void);

复制代码

1. /* FreeRTOSConfig.h */
2. // 支持抢占优先级
3. #define configUSE_PREEMPTION                    1

复制代码

2.4、xPortSysTickHandler( )

无其他变化，只是将任务切换从函数体内修改到函数体外

1. /* port.c */
2. // SysTick 中断
3. void xPortSysTickHandler(void)
4. {
5.         // 关中断
6.         vPortRaiseBASEPRI();
7.         // 更新系统时基
8.         if(xTaskIncrementTick() != pdFALSE)
9.         {
10.                 taskYIELD();
11.         }
12.         // 开中断
13.         vPortSetBASEPRI(0);
14. }

复制代码

3、实验

3.1、测试

与 FreeRTOS简单内核实现6 优先级 文章中 "3.1、测试" 小节内容一致
如果使用的开发环境为 Keil 且程序工作不正常，可以勾选 Use MicroLIB 试试，如下图所示

3.2、待改进

当前 RTOS 简单内核已实现的功能有

• 静态方式创建任务
  
• 手动切换任务
  
• 临界段保护
  
• 任务阻塞延时
  
• 支持任务优先级
  
• 阻塞链表
  

当前 RTOS 简单内核存在的缺点有

• 不支持时间片轮询
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！