【LPC845-BRK板卡试用申请】(九)任务使用栈深度计算

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

复制代码

对应配置代码如下：

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. #include "fsl_debug_console.h"
    
12. 
    
13. #if ((configUSE_STACK_MAX_USAGE == 0 )&& (configUSE_PERF_CNT == 1))
    
14.     #error perf is depend on configUSE_STACK_MAX_USAGE = 1
    
15. #endif
    
16. 
    
17. 
    
18. #if ( configUSE_STACK_MAX_USAGE == 1 )
    
19. 
    
20. struct task_stack_info
    
21. {
    
22.     char task_name[configMAX_TASK_NAME_LEN];
    
23.     uint32_t stack_deep;
    
24.     uint32_t*  stack_tail;
    
25. };
    
26. 
    
27. #define OS_NUM_TASKS 4
    
28. 
    
29. static struct task_stack_info stack_all[OS_NUM_TASKS+2]; //add timer & idle
    
30. 
    
31. 
    
32. void task_create_hook_stack(char * name ,unsigned int deep,unsigned int * stack_tail)
    
33. {
    
34.     static uint8_t i_loop = 0;
    
35.     uint8_t len,i;
    
36. 
    
37.     if(i_loop < OS_NUM_TASKS+2)
    
38.     {
    
39.         strcpy(stack_all[i_loop].task_name,name);
    
40.         if((len = strlen(stack_all[i_loop].task_name)) != (configMAX_TASK_NAME_LEN-1))
    
41.         {
    
42.             for(i = len;i < configMAX_TASK_NAME_LEN-1;i++)
    
43.                 stack_all[i_loop].task_name[i] = '\0';
    
44.         }
    
45.         stack_all[i_loop].task_name[configMAX_TASK_NAME_LEN-1] = '\0';
    
46.         stack_all[i_loop].stack_deep = deep*4;
    
47.         stack_all[i_loop].stack_tail = stack_tail;
    
48.         /* if use pref to set perf default value */
    
49. #if ( configUSE_PERF_CNT == 1 )
    
50.         memset((void*)stack_all[i_loop].stack_tail,0,sizeof(task_cycle_info_t)+8);
    
51. #endif
    
52.         i_loop++;
    
53.     }
    
54.     else
    
55.     {
    
56.         PRINTF("array is overflow \r\n");
    
57.     }
    
58. }
    
59. 
    
60. #if 0
    
61. void get_cur_thread_stack_info(uint32_t sp, uint32_t *start_addr, size_t *size)
    
62. {
    
63.     uint8_t i_loop = 0;
    
64.     extern __no_init volatile char switchintaskname[configMAX_TASK_NAME_LEN];
    
65. 
    
66.     for(i_loop = 0;i_loop< OS_NUM_TASKS+2;i_loop++)
    
67.     {
    
68.         if(strcmp(stack_all[i_loop].task_name,(const char *)switchintaskname) == 0)
    
69.             break;
    
70.         if((sp > (uint32_t)stack_all[i_loop].stack_tail) && ( sp < ((uint32_t)stack_all[i_loop].stack_tail)+stack_all[i_loop].stack_deep))
    
71.             break;
    
72.     }
    
73.     /* find stack info update */
    
74.     if(i_loop != OS_NUM_TASKS+2)
    
75.     {
    
76.         *start_addr = (uint32_t)stack_all[i_loop].stack_tail;
    
77.         *size = stack_all[i_loop].stack_deep;
    
78.     }
    
79.     else
    
80.     {
    
81.          *size = 0;
    
82.     }
    
83. }
    
84. #endif
    
85. 
    
86. static int buff_continuous_numbers(uint8_t * buff,uint8_t data)
    
87. {
    
88.     int l = 0;
    
89. 
    
90.     if(NULL == buff)
    
91.         return 0;
    
92. 
    
93.     while(data == buff[l++]);
    
94. 
    
95.     return  --l;
    
96. }
    
97. 
    
98. extern size_t xPortGetFreeHeapSize( void );
    
99. 
    
100. unsigned int stack(char argc,char ** argv)
     
101. {
     
102.     uint8_t i,j;
     
103.     int len,name_len;
     
104.     char task_name[configMAX_TASK_NAME_LEN];
     
105. 
     
106.     if(argc == 1)
     
107.     {
     
108.         //logctrl_instance()->is_sync = 1;
     
109.         PRINTF("taskname\tdeep\tused\taddress\t\t\tusage\r\n");
     
110.         for(i = 0;i < OS_NUM_TASKS+2;i++)
     
111.         {
     
112. #if ( configUSE_PERF_CNT != 1 )
     
113.             len = buff_continuous_numbers((uint8_t *)stack_all[i].stack_tail,0xa5);
     
114. #else
     
115.             len = buff_continuous_numbers((uint8_t *)&stack_all[i].stack_tail[WORD_OF_CYCEL_INFO],0xa5);
     
116.             if(len)
     
117.                 len += BYTE_OF_CYCEL_INFO;
     
118. #endif
     
119.         strcpy(task_name,stack_all[i].task_name);
     
120.         task_name[configMAX_TASK_NAME_LEN - 1] = '\0';
     
121.         if((name_len = strlen(stack_all[i].task_name)) != (configMAX_TASK_NAME_LEN-1))
     
122.         {
     
123.             for(j = name_len;j < configMAX_TASK_NAME_LEN-1;j++)
     
124.                 task_name[j] = ' ';
     
125.         }
     
126.             PRINTF("%s\t%d\t%d\t0x%p~0x%p\t%d%%\r\n",task_name,stack_all[i].stack_deep,stack_all[i].stack_deep-len,stack_all[i].stack_tail,stack_all[i].stack_tail+(stack_all[i].stack_deep/4),(100-(len*100)/stack_all[i].stack_deep));
     
127.         }
     
128.         PRINTF("\r\nHeap Total:%d\tFree:%d\r\n",configTOTAL_HEAP_SIZE,xPortGetFreeHeapSize());
     
129.         //logctrl_instance()->is_sync = 0;
     
130.     }
     
131.     if(argc == 2)
     
132.     {
     
133.         uint8_t index = atoi(argv[1]);
     
134.         if(index >=  OS_NUM_TASKS+2)
     
135.             goto out;
     
136.         PRINTF("task name [%s] stack deep 0x%x\r\n",stack_all[index].task_name,stack_all[index].stack_deep);
     
137.         //logctrl_instance()->is_sync = 1;
     
138.         trace_byte_stream((uint8_t *)stack_all[index].stack_tail,stack_all[index].stack_deep);
     
139.         //logctrl_instance()->is_sync = 0;
     
140.     }
     
141. out:
     
142.     return 0;
     
143. }
     
144. 
     
145. LTSH_FUNCTION_EXPORT(stack,"show task statck info");
     
146. #endif /* end of configUSE_STACK_MAX_USAGE */

复制代码

运行效果：

可以检测堆栈最大使用率，我们来对比下不同的编译选项对堆栈的使用率的数据，我们使用的是gcc的编译器。

o0 编译选项的资源及堆栈使用情况：

o1 编译选项的资源及堆栈使用情况：

o2 编译选项的资源及堆栈使用情况：

o3 编译选项的资源及堆栈使用情况：

oS 编译选项的资源及堆栈使用情况：

oG 编译选项的资源及堆栈使用情况：

=================代码如下=================

https://github.com/andeyqi/LPC845BRK

阅读全文

jobszheng5

这个功能很早就知道。可是一直没有使用过。

andeyqi

jobszheng5 发表于 2023-8-31 14:33
这个功能很早就知道。可是一直没有使用过。

功能不复杂实现起来也用不了多少代码量，集成在系统里作为个小工具使用

jobszheng5

坦白讲，现在项目开发的，能在时间内完成，通过验证就够累的，没有时间进行二次优化重构了。