【Telink-泰凌微电子 B91通用开发套件】(四)FreeRtos任务栈统计

andeyqi

简介：

       嵌入式开发中我们通常对任务栈的大小设置通常根据经验值来设定，设置的小了会造成栈溢出，设置大了会造成资源的浪费。如果能够计算出栈在任务过程中使用的最大深度的话对就可以根据实际情况来设置避免资源的浪费。计算任务栈的使用大小通常使用水印法，初始化时将栈设置为特定的magic ,栈内未使用的部分会时连续的magic,连续magic 的大小和栈的总深度的比较即可计算出栈的最大使用率。

实现方式：
本次实现基于freertos来实现，上述的实现方式主要需要实现如下几个部分：
1.创建任务的时候将任务栈初始化为特定的magic(0xa5)
2.将任务tcb信息中的栈的起始地址和栈深度缓存下来
3.计算栈的非踩踏区域的长度和栈深度计算栈的最大使用率


1.创建任务的时候将任务栈初始化为特定的magic(0xa5)

FreeRTOS 创建任务的时候会根据配置项目，决定是否将栈初始化特定的magic,代码如下：

只要配置 tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1就会初始化栈为特定的魔数（0xa5）,  通过如下代码可知配置configUSE_STACK_MAX_USAGE  = 1 会定义tskSET_NEW_STACKS_TO_KNOWN_VALUE = 1，我们在freertos 的配置文件中定义该宏即可

1. /* If any of the following are set then task stacks are filled with a known
   
2. * value so the high water mark can be determined.  If none of the following are
   
3. * set then don't fill the stack so there is no unnecessary dependency on memset. */
   
4. #if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) || (configUSE_STACK_MAX_USAGE == 1))
   
5.     #define tskSET_NEW_STACKS_TO_KNOWN_VALUE    1
   
6. #else
   
7.     #define tskSET_NEW_STACKS_TO_KNOWN_VALUE    0
   
8. #endif

复制代码

对应FreeRtos配置追加如下宏配置：

修改如下配置将在栈创建深度信息通知给hook函数处理，修改如下：

2.将任务tcb信息中的栈的起始地址和栈深度缓存下来

freertos 有很多hook 函数时可以供用户使用来劫持操作系统的信息，我们可以通过如下的回调函数（traceTASK_CREATE）截取系统的栈信息。

3.计算栈的非踩踏区域的长度和栈深度计算栈的最大使用率

添加stack 命令计算显示当前的栈信息，代码如下。

1. #include <stdint.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include "FreeRTOS.h"
   
6. #if (configUSE_PERF_CNT == 1)
   
7. #include "perf_counter.h"
   
8. #endif
   
9. #include "littleshell.h"
   
10. #include "trace_dump.h"
    
11. 
    
12. #if ((configUSE_STACK_MAX_USAGE == 0 )&& (configUSE_PERF_CNT == 1))
    
13.     #error perf is depend on configUSE_STACK_MAX_USAGE = 1
    
14. #endif
    
15. 
    
16. 
    
17. #if ( configUSE_STACK_MAX_USAGE == 1 )
    
18. 
    
19. struct task_stack_info
    
20. {
    
21.     char task_name[configMAX_TASK_NAME_LEN];
    
22.     uint32_t stack_deep;
    
23.     uint32_t*  stack_tail;
    
24. };
    
25. 
    
26. struct task_stack_info_tbl
    
27. {
    
28.     uint8_t num;
    
29.     struct task_stack_info * tasks;
    
30. };
    
31. 
    
32. #define OS_NUM_TASKS_SUPPORT 10
    
33. 
    
34. static struct task_stack_info stack_all[OS_NUM_TASKS_SUPPORT];
    
35. 
    
36. static struct task_stack_info_tbl task_stacks =
    
37. {
    
38.     .num = 0,
    
39.     .tasks = stack_all,
    
40. };
    
41. 
    
42. 
    
43. #define TASK_STACK_NAME(i) task_stacks.tasks[i].task_name
    
44. #define TASK_STACK_DEEP(i) task_stacks.tasks[i].stack_deep
    
45. #define TASK_STACK_TAIL(i) task_stacks.tasks[i].stack_tail
    
46. #define TASK_STACK_TAIL_OFF_ADDR(i,off) &task_stacks.tasks[i].stack_tail[off]
    
47. 
    
48. 
    
49. 
    
50. void task_create_hook_stack(char * name ,unsigned int deep,unsigned int * stack_tail)
    
51. {
    
52.     uint8_t i_loop = task_stacks.num;
    
53.     uint8_t len,i;
    
54.     char * p_task_name;
    
55. 
    
56.     if(i_loop < OS_NUM_TASKS_SUPPORT)
    
57.     {
    
58.         p_task_name = TASK_STACK_NAME(i_loop);
    
59.         strcpy(TASK_STACK_NAME(i_loop),name);
    
60.         if((len = strlen(TASK_STACK_NAME(i_loop))) != (configMAX_TASK_NAME_LEN-1))
    
61.         {
    
62.             for(i = len;i < configMAX_TASK_NAME_LEN-1;i++)
    
63.                 p_task_name[i] = '\0';
    
64.         }
    
65.         p_task_name[configMAX_TASK_NAME_LEN-1] = '\0';
    
66.         TASK_STACK_DEEP(i_loop) = deep*4;
    
67.         TASK_STACK_TAIL(i_loop) = stack_tail;
    
68.         /* if use pref to set perf default value */
    
69. #if ( configUSE_PERF_CNT == 1 )
    
70.         memset((void*)TASK_STACK_TAIL(i_loop),0,sizeof(task_cycle_info_t)+8);
    
71. #endif
    
72.         task_stacks.num++;
    
73.     }
    
74.     else
    
75.     {
    
76.         printf("task num is max than OS_NUM_TASKS_SUPPORT.\r\n");
    
77.     }
    
78. }
    
79. 
    
80. 
    
81. static int buff_continuous_numbers(uint8_t * buff,uint8_t data)
    
82. {
    
83.     int l = 0;
    
84. 
    
85.     if(NULL == buff)
    
86.         return 0;
    
87. 
    
88.     while(data == buff[l++]);
    
89. 
    
90.     return  --l;
    
91. }
    
92. 
    
93. extern size_t xPortGetFreeHeapSize( void );
    
94. 
    
95. unsigned int stack(char argc,char ** argv)
    
96. {
    
97.     uint8_t i,j;
    
98.     int len,name_len;
    
99.     char task_name[configMAX_TASK_NAME_LEN];
    
100. 
     
101.     if(argc == 1)
     
102.     {
     
103.         //logctrl_instance()->is_sync = 1;
     
104.         printf("taskname\tdeep\tused\taddress\t\t\tusage\r\n");
     
105.         for(i = 0;i < task_stacks.num;i++)
     
106.         {
     
107. #if ( configUSE_PERF_CNT != 1 )
     
108.             len = buff_continuous_numbers((uint8_t *)TASK_STACK_TAIL(i),0xa5);
     
109. #else
     
110.             len = buff_continuous_numbers((uint8_t *)TASK_STACK_TAIL_OFF_ADDR(i,WORD_OF_CYCEL_INFO),0xa5);
     
111.             if(len)
     
112.                 len += BYTE_OF_CYCEL_INFO;
     
113. #endif
     
114.         strcpy(task_name,TASK_STACK_NAME(i));
     
115.         task_name[configMAX_TASK_NAME_LEN - 1] = '\0';
     
116.         if((name_len = strlen(TASK_STACK_NAME(i))) != (configMAX_TASK_NAME_LEN-1))
     
117.         {
     
118.             for(j = name_len;j < configMAX_TASK_NAME_LEN-1;j++)
     
119.                 task_name[j] = ' ';
     
120.         }
     
121.             printf("%s\t%d\t%d\t0x%08p~0x%08p\t%d%%\r\n",task_name,TASK_STACK_DEEP(i),
     
122.             TASK_STACK_DEEP(i)-len,TASK_STACK_TAIL(i),
     
123.             TASK_STACK_TAIL(i)+(TASK_STACK_DEEP(i)/4),(100-(len*100)/TASK_STACK_DEEP(i)));
     
124.         }
     
125.         printf("\r\nHeap Total:%d\tFree:%d\r\n",configTOTAL_HEAP_SIZE,xPortGetFreeHeapSize());
     
126.         //logctrl_instance()->is_sync = 0;
     
127.     }
     
128.     if(argc == 2)
     
129.     {
     
130.         uint8_t index = atoi(argv[1]);
     
131.         if(index >=  task_stacks.num)
     
132.             goto out;
     
133.         printf("task name [%s] stack deep 0x%x\r\n",TASK_STACK_NAME(index),TASK_STACK_DEEP(index));
     
134.         //logctrl_instance()->is_sync = 1;
     
135.         trace_byte_stream((uint8_t *)TASK_STACK_TAIL(index),TASK_STACK_DEEP(index),0);
     
136.         //logctrl_instance()->is_sync = 0;
     
137.     }
     
138. out:
     
139.     return 0;
     
140. }
     
141. 
     
142. //LTSH_FUNCTION_EXPORT(stack,"show task statck info");
     
143. 
     
144. #if ( configUSE_PERF_CNT == 1 )
     
145. 
     
146. unsigned int perf(char argc,char ** argv)
     
147. {
     
148.     uint8_t i,j,len;
     
149.     int64_t count = get_system_ticks();
     
150.     char task_name[configMAX_TASK_NAME_LEN];
     
151. 
     
152.     //logctrl_instance()->is_sync = 1;
     
153.     if(argc == 1)
     
154.     {
     
155.         printf("taskname\trecent\t\tactive\tusedmax\t\tusedmin\t\tusedavg\t\tcpuusage\r\n");
     
156.         for(i = 0;i < task_stacks.num;i++)
     
157.         {
     
158.             task_cycle_info_t * pcycle = get_rtos_task_cycle_info_by_stack(TASK_STACK_TAIL(i));
     
159.             task_name[configMAX_TASK_NAME_LEN - 1] = '\0';
     
160.             strcpy(task_name,TASK_STACK_NAME(i));
     
161.             if((len = strlen(TASK_STACK_NAME(i))) != (configMAX_TASK_NAME_LEN-1))
     
162.             {
     
163.                 for(j = len;j < configMAX_TASK_NAME_LEN-1;j++)
     
164.                     task_name[j] = ' ';
     
165.             }
     
166.             printf("%s\t%010d\t%d\t%010d\t%010d\t%010d\t%.2f\r\n",
     
167.                    task_name,pcycle->nUsedRecent,pcycle->wActiveCount,
     
168.                    pcycle->nUsedMax,pcycle->nUsedMin,pcycle->lUsedTotal/pcycle->wActiveCount,
     
169.                    ((double)(pcycle->lUsedTotal))/((double)count)*((double)100.0f));
     
170.         }
     
171.     }
     
172.     //logctrl_instance()->is_sync = 0;
     
173.     return 0;
     
174. }
     
175. 
     
176. LTSH_FUNCTION_EXPORT(perf,"show perf info");
     
177. #endif
     
178. 
     
179. #endif /* end of configUSE_STACK_MAX_USAGE */
     
180. 
     

复制代码

运行效果：

输入stack 命令即可查看当前任务的栈使用深度，根据输出结果来确认栈大小设置是否合理。

==================资料分割线==================

代码和官方下载的资料已上传至如下git路径

https://gitee.com/andeyqi/telink-b91