通知分析

        在FreeRTOS版本V8.2.0中推出了全新的功能：任务通知。在大多数情况下，任务通知可以替代二进制信号量、计数信号量、事件组，可以替代长度为1的队列（可以保存一个32位整数或指针值），并且任务通知速度更快、使用的RAM更少！我在《 FreeRTOS系列第14篇---FreeRTOS任务通知》一文中介绍了任务通知如何使用以及局限性，今天我们将分析任务通知的实现源码，看一下任务通知是如何做到效率与RAM消耗双赢的。
        在《FreeRTOS高级篇6---FreeRTOS信号量分析》一文中我们已经知道，FreeRTOS的信号量是使用队列机制实现的，数据结构也完全是队列的那一套。而任务通知则不同，它的数据结构嵌在任务TCB（任务控制块，见《FreeRTOS高级篇2---FreeRTOS任务创建分析》）中的，并且数据结构十分简单，涉及到任务TCB的两个字段，我们将它单独列出来：

[objc] view plain copy

 print?

1. volatile uint32_t ulNotifiedValue;  /*任务通知值*/    
2. volatile uint8_t ucNotifyState; /*任务通知状态，标识任务是否在等待通知等*/  

这两个字段占用5字节RAM（本文都是在32位系统下讨论），而一个队列数据结构至少占用76字节RAM！这不是同一数量级的，所以任务通知在RAM消耗上完胜。
在分析队列和信号量的文章中，我们知道在使用队列、信号量前，必须先创建队列和信号量，目的是为了创建队列数据结构。比如使用API函数xQueueCreate()创建队列，用API函数xSemaphoreCreateBinary()创建二进制信号量等等。再来看任务通知，由于任务通知的数据结构包含在任务TCB中，只要任务存在，任务通知数据结构就已经创建完毕，可以直接使用！在易用性上，任务通知再次获胜。
要想了解任务通知在性能上占优的原因，就要分析源代码了。
只有任务可以等待通知，中断服务函数中不可以。如果等待的通知无效，任务会进入阻塞状态，我们可以将等待通知的任务看作是消费者；其它任务和中断可以向等待通知的任务发送通知，发送通知的任务和中断服务函数可以认为是生产者。处于阻塞的消费者得到通知后会再次进入就绪态。
任务通知API函数主要有两类，一类发送通知，一类等待通知。发送通知API函数可以用于任务和中断服务函数，等待通知API函数只能用在任务中。

1.发送通知

      我们先看一下发送通知API函数。这类函数比较多，有6个。但仔细分析会发现它们只能完成3种操作，每种操作有两个API函数，分别为带中断保护版本和不带中断保护版本。FreeRTOS将API细分为带中断保护版本和不带中断保护版本是为了节省中断服务程序处理时间，提升性能。
和信号量类似，大多数发送通知API接口也是由宏实现的，如表1-1所示。

表1-1：发送通知API函数与实际调用函数列表

1.1 xTaskGenericNotify()

不带中断保护的发送通知API函数实际都是调用函数xTaskGenericNotify()实现的，我们看一下这个函数原型：

[objc] view plain copy

 print?

1. BaseType_t xTaskGenericNotify(   
2.         TaskHandle_t xTaskToNotify,   
3.         uint32_t ulValue,   
4.         eNotifyAction eAction,   
5.         uint32_t *pulPreviousNotificationValue )  

• xTaskToNotify：被通知的任务句柄。
• ulValue：更新的通知值
• eAction：枚举类型，指明更新通知值的方法，枚举变量成员以及作用见表1-2所示。
• pulPreviousNotifyValue：回传未被更新的任务通知值。如果不需要回传未被更新的任务通知值，这里设置为NULL。

表1-2：eNotifyAction枚举成员以及作用

与入队操作相比较，发送通知API函数显得非常简单，整理后的源码如下所示：

[objc] view plain copy

 print?

1. BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )  
2. {  
3. TCB_t * pxTCB;  
4. BaseType_t xReturn = pdPASS;  
5. uint8_t ucOriginalNotifyState;  
6.   
7.   
8.     configASSERT( xTaskToNotify );  
9.     pxTCB = ( TCB_t * ) xTaskToNotify;  
10.   
11.   
12.     taskENTER_CRITICAL();  
13.     {  
14.         if( pulPreviousNotificationValue != NULL )  
15.         {  
16.             /* 回传更新前的通知值*/  
17.             *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;  
18.         }  
19.   
20.   
21.         ucOriginalNotifyState = pxTCB->ucNotifyState;  
22.   
23.   
24.         pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;  
25.   
26.   
27.         switch( eAction )  
28.         {  
29.             case eSetBits   :  
30.                 pxTCB->ulNotifiedValue |= ulValue;  
31.                 break;  
32.   
33.   
34.             case eIncrement :  
35.                 ( pxTCB->ulNotifiedValue )++;  
36.                 break;  
37.   
38.   
39.             case eSetValueWithOverwrite :  
40.                 pxTCB->ulNotifiedValue = ulValue;  
41.                 break;  
42.   
43.   
44.             case eSetValueWithoutOverwrite :  
45.                 if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )  
46.                 {  
47.                     pxTCB->ulNotifiedValue = ulValue;  
48.                 }  
49.                 else  
50.                 {  
51.                     /* 上次的通知值还未取走,本次通知值丢弃 */  
52.                     xReturn = pdFAIL;  
53.                 }  
54.                 break;  
55.   
56.   
57.             case eNoAction:  
58.                 /* 不需要更新通知值*/  
59.                 break;  
60.         }  
61.   
62.   
63.         traceTASK_NOTIFY();  
64.   
65.   
66.         /* 如果被通知的任务因为等待通知而阻塞,现在将它解除阻塞 */  
67.         if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )  
68.         {  
69.             ( void ) uxListRemove( &( pxTCB->xStateListItem ) );  
70.             prvAddTaskToReadyList( pxTCB );  
71.   
72.   
73.             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )  
74.             {  
75.                 /* 如果被通知的任务优先级高于当前任务,则触发PendSV中断,退出临界区后进行上下文切换T*/  
76.                 taskYIELD_IF_USING_PREEMPTION();  
77.             }  
78.         }  
79.     }  
80.     taskEXIT_CRITICAL();  
81.   
82.   
83.     return xReturn;  
84. }  

函数的功能可以概括为：按照指定的方法更新通知值，如果被通知的任务处于阻塞状态，则将它解除阻塞，解除阻塞任务的优先级如果大于当前任务的优先级，则触发一次任务切换。
与释放信号量API函数相比，本函数少了很多调用子函数开销、少了很多判断、少了对事件列表的操作等等，确实是比释放信号量的实现要简洁的多。这也是有原因的，因为任务通知有它自己的局限性，并不能完全代替信号量。比如一个任务只能阻塞到一个通知上，如想要实现多个任务阻塞到同一个事件上，只能使用信号量了。也正是因为这种局限性，使得任务通知实现起来简单高效，并且大多数情况下，任务通知的方法就已经能解决问题了。

1.2vTaskNotifyGiveFromISR()

这个API函数是vTaskNotifyGive()的带中断保护版本，是专门设计用来在某些情况下代替二进制信号量和计数信号量的。函数也很简单，我们直接看源码，源码经过整理和注释，以方便理解。

[objc] view plain copy

 print?

1. void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )  
2. {  
3. TCB_t * pxTCB;  
4. uint8_t ucOriginalNotifyState;  
5. UBaseType_t uxSavedInterruptStatus;  
6.   
7.   
8.     pxTCB = ( TCB_t * ) xTaskToNotify;  
9.   
10.   
11.     uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();  
12.     {  
13.         ucOriginalNotifyState = pxTCB->ucNotifyState;  
14.         pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;  
15.   
16.   
17.         /* 通知值加1,相当于释放了一个信号量 */  
18.         ( pxTCB->ulNotifiedValue )++;  
19.   
20.   
21.         /* 如果目标任务因为等待通知而阻塞,现在将它解除阻塞*/  
22.         if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )  
23.         {  
24.             /* 如果调度器正常,将任务放入就绪列表,否则放入挂起就绪列表 */  
25.             if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )  
26.             {  
27.                 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );  
28.                 prvAddTaskToReadyList( pxTCB );  
29.             }  
30.             else  
31.             {  
32.                 vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );  
33.             }  
34.   
35.   
36.             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )  
37.             {  
38.                 /* 如果解除阻塞的任务优先级大于当前任务优先级,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文*/  
39.                 if( pxHigherPriorityTaskWoken != NULL )  
40.                 {  
41.                     *pxHigherPriorityTaskWoken = pdTRUE;    /* 设置手动切换标志 */  
42.                 }  
43.                 else  
44.                 {  
45.                     xYieldPending = pdTRUE;                 /* 设置自动切换标志 */  
46.                 }  
47.             }  
48.         }  
49.     }  
50.     portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );  
51. }  

1.3  xTaskGenericNotifyFromISR()

        如表1-1所示，带中断保护版本的API函数xTaskNotifyFromISR()和xTaskNotifyAndQueryFromISR()都是宏定义，真正被调用的函数为xTaskGenericNotifyFromISR()。这个函数用于在中断在中发送通知，与不带中断保护的API函数xTaskGenericNotify()非常相似，只是增加了一些中断保护措施，我们直接看源码。通用源码经过整理和注释，以方便理解。

[objc] view plain copy

 print?

1. BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken )  
2. {  
3. TCB_t * pxTCB;  
4. uint8_t ucOriginalNotifyState;  
5. BaseType_t xReturn = pdPASS;  
6. UBaseType_t uxSavedInterruptStatus;  
7.   
8.   
9.     pxTCB = ( TCB_t * ) xTaskToNotify;  
10.   
11.   
12.     uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();  
13.     {  
14.         if( pulPreviousNotificationValue != NULL )  
15.         {  
16.             /* 回传更新前的通知值 */  
17.             *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;  
18.         }  
19.   
20.   
21.         ucOriginalNotifyState = pxTCB->ucNotifyState;  
22.         pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;  
23.           
24.         /* 根据参数设置通知值 */  
25.         switch( eAction )  
26.         {  
27.             case eSetBits   :  
28.                 pxTCB->ulNotifiedValue |= ulValue;  
29.                 break;  
30.   
31.   
32.             case eIncrement :  
33.                 ( pxTCB->ulNotifiedValue )++;  
34.                 break;  
35.   
36.   
37.             case eSetValueWithOverwrite :  
38.                 pxTCB->ulNotifiedValue = ulValue;  
39.                 break;  
40.   
41.   
42.             case eSetValueWithoutOverwrite :  
43.                 if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )  
44.                 {  
45.                     pxTCB->ulNotifiedValue = ulValue;  
46.                 }  
47.                 else  
48.                 {  
49.                     /* 上次的通知值还未取走,本次通知值丢弃 */  
50.                     xReturn = pdFAIL;  
51.                 }  
52.                 break;  
53.   
54.   
55.             case eNoAction :  
56.                 /* 不需要更新通知值*/  
57.                 break;  
58.         }  
59.   
60.   
61.         traceTASK_NOTIFY_FROM_ISR();  
62.   
63.   
64.         /* 如果被通知的任务因为等待通知而阻塞,现在将它解除阻塞 */  
65.         if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )  
66.         {     
67.             /* 如果调度器正常,将任务放入就绪列表,否则放入挂起就绪列表 */  
68.             if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )  
69.             {  
70.                 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );  
71.                 prvAddTaskToReadyList( pxTCB );  
72.             }  
73.             else  
74.             {  
75.                 vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );  
76.             }  
77.   
78.   
79.             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )  
80.             {  
81.                 /* 如果解除阻塞的任务优先级大于当前任务优先级,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文*/  
82.                 if( pxHigherPriorityTaskWoken != NULL )  
83.                 {  
84.                     *pxHigherPriorityTaskWoken = pdTRUE;    /* 设置手动切换标志 */  
85.                 }  
86.                 else  
87.                 {  
88.                     xYieldPending = pdTRUE;                 /* 设置自动切换标志 */  
89.                 }  
90.             }  
91.         }  
92.     }  
93.     portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );  
94.   
95.   
96.     return xReturn;  
97. }  

2.等待通知

        等待通知API函数只能用在任务中，没有带中断保护版本，因此只有两个API函数：ulTaskNotifyTake()和xTaskNotifyWait ()。前者是为代替二进制信号量和计数信号量而专门设计的，它和发送通知API函数xTaskNotifyGive()、vTaskNotifyGiveFromISR()配合使用；后者是全功能版的等待通知，可以根据不同的参数实现轻量级二进制信号量、计数信号量、事件组和长度为1的队列。
        等待通知API函数都带有最大阻塞时间参数，当任务因为等待通知而进入阻塞时，用来规定最大阻塞时间。

2.1 ulTaskNotifyTake()

这个API函数用于实现轻量级的二进制信号量和计数信号量，源码如下所示。它有两个参数，如果第一个参数xClearCountOnExit设置为pdFALSE，则用来实现二进制信号量，函数退出时将通知值清零；如果第一个参数设置为pdTRUE，则用来实现计数信号量，函数退出时，将通知值减一。

[objc] view plain copy

 print?

1. uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )  
2. {  
3. uint32_t ulReturn;  
4.   
5.   
6.     taskENTER_CRITICAL();  
7.     {  
8.         /* 仅当通知值为0，才进行阻塞操作*/  
9.         if( pxCurrentTCB->ulNotifiedValue == 0UL )  
10.         {  
11.             /* 设置标志,表示当前任务等待一个通知*/  
12.             pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;  
13.   
14.   
15.             if( xTicksToWait > ( TickType_t ) 0 )  
16.             {     
17.                 /* 将任务加入延时列表 */  
18.                 prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );  
19.                 traceTASK_NOTIFY_TAKE_BLOCK();  
20.   
21.   
22.                 /* 触发PendSV中断,等到退出临界区时立即执行任务切换 */  
23.                 portYIELD_WITHIN_API();  
24.             }  
25.         }  
26.     }  
27.     taskEXIT_CRITICAL();  
28.     /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/  
29.     taskENTER_CRITICAL();  
30.     {  
31.         traceTASK_NOTIFY_TAKE();  
32.         ulReturn = pxCurrentTCB->ulNotifiedValue;     
33.   
34.   
35.         if( ulReturn != 0UL )  
36.         {  
37.             if( xClearCountOnExit != pdFALSE )  
38.             {  
39.                 pxCurrentTCB->ulNotifiedValue = 0UL;  
40.             }  
41.             else  
42.             {  
43.                 pxCurrentTCB->ulNotifiedValue = ulReturn - 1;  
44.             }  
45.         }  
46.         /* 设置标志,表示不需要等待通知 */  
47.         pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;  
48.     }  
49.     taskEXIT_CRITICAL();  
50.   
51.   
52.     return ulReturn;    /* 如果返回值为0,说明是任务阻塞超时了 */  
53. }  

与获取二进制信号量和获取计数信号量函数相比，本函数少了很多调用子函数开销、少了很多判断、少了事件列表处理、少了队列上锁与解锁处理等等，因此本函数相对效率很高。

2.2xTaskNotifyWait()

这个函数用于实现全功能版的等待通知，根据参数的不同，可以灵活的用于实现轻量级的队列、二进制信号量、计数信号量和事件组功能，函数原型为：

[objc] view plain copy

 print?

1. BaseType_t xTaskNotifyWait( uint32_tulBitsToClearOnEntry,  
2.                      uint32_tulBitsToClearOnExit,  
3.                      uint32_t*pulNotificationValue,  
4.                      TickType_txTicksToWait );  

• ulBitsToClearOnEntry：在使用通知之前，先将任务的通知值与参数ulBitsToClearOnEntry的按位取反值按位与操作。设置参数ulBitsToClearOnEntry为0xFFFFFFFF(ULONG_MAX)，表示清零任务通知值。
• ulBitsToClearOnExit：在函数xTaskNotifyWait()退出前，将任务的通知值与参数ulBitsToClearOnExit的按位取反值按位与操作。设置参数ulBitsToClearOnExit为0xFFFFFFFF(ULONG_MAX)，表示清零任务通知值。
• pulNotificationValue：用于向外回传任务的通知值。这个通知值在参数ulBitsToClearOnExit起作用前将通知值拷贝到*pulNotificationValue中。如果不需要返回任务的通知值，这里设置成NULL。
• xTicksToWait：因等待通知而进入阻塞状态的最大时间。时间单位为系统节拍周期。宏pdMS_TO_TICKS用于将指定的毫秒时间转化为相应的系统节拍数。

这个函数的实现和ulTaskNotifyTake()有很多相通之处，我将整个流程以注释形式置于源码中，源码如下所示：

[objc] view plain copy

 print?

1. BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )  
2. {  
3. BaseType_t xReturn;  
4.   
5.   
6.     taskENTER_CRITICAL();  
7.     {  
8.         /* 只有任务没有等待通知，才会将任务阻塞 */  
9.         if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )  
10.         {  
11.             /* 使用任务通知值之前,先将参数ulBitsToClearOnEntryClear取反后与任务通知值位与.可以用这种方法在使用任务通知值之前,将通知值的某些或全部位清零 */  
12.             pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;  
13.   
14.   
15.             /* 设置任务状态标识:等待通知 */  
16.             pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;  
17.   
18.   
19.             if( xTicksToWait > ( TickType_t ) 0 )  
20.             {  
21.                 /* 阻塞当前任务 */  
22.                 prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );  
23.                 traceTASK_NOTIFY_WAIT_BLOCK();  
24.   
25.   
26.                 /* 触发PendSV中断,等到退出临界区后,执行任务切换 */  
27.                 portYIELD_WITHIN_API();  
28.             }  
29.         }  
30.     }  
31.     taskEXIT_CRITICAL();  
32.   
33.   
34.     /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/  
35.     taskENTER_CRITICAL();  
36.     {  
37.         traceTASK_NOTIFY_WAIT();  
38.   
39.   
40.         if( pulNotificationValue != NULL )  
41.         {  
42.             /* 输出当前通知值,通过指针参数传递*/  
43.             *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;  
44.         }  
45.   
46.   
47.         /* 判断是否是因为任务阻塞超时 */  
48.         if( pxCurrentTCB->ucNotifyState == taskWAITING_NOTIFICATION )  
49.         {  
50.             /* 没有收到任务通知,是阻塞超时 */  
51.             xReturn = pdFALSE;  
52.         }  
53.         else  
54.         {  
55.             /* 收到任务值,先将参数ulBitsToClearOnExit取反后与通知值位与,用于在退出函数前,将通知值的某些或者全部位清零. */  
56.             pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;  
57.             xReturn = pdTRUE;  
58.         }  
59.         /* 更改任务通知状态,解除任务通知等待 */  
60.         pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;  
61.     }  
62.     taskEXIT_CRITICAL();  
63.   
64.   
65.     return xReturn;  
66. }  

纵观整个任务通知的实现，可以发现它比队列、信号量相比要简单很多。它可以实现轻量级的队列、二进制信号量、计数信号量和事件组，并且使用更方便、更节省RAM、更高效。FreeRTOS的作者做过测试，在同一平台下，使用使用GCC编译器、-o2优化级别，相比使用信号量解除任务阻塞，使用任务通知可以快45%！这个性能的提升是巨大的。我们分析过信号量的源码，今天又分析了任务通知的源码，这使得我们知道，之所以有这么大的性能提升，一方面缘于任务通知数据结构简单、实现简洁；另一方面也跟FreeRTOS的信号量机制臃肿、效率低下有关。因为信号量的实现全部是使用队列机制，并没有为信号量做专门优化。
此外，着重说明一下任务通知并不能完全代替队列、二进制信号量、计数信号量和事件组，任务通知有自己的局限性，我们就以它的局限性来结束本文：

• 只能有一个任务接收通知事件。
• 接收通知的任务可以因为等待通知而进入阻塞状态，但是发送通知的任务即便不能立即完成发送通知，也不能进入阻塞状态。