请教一下，ThreadX定时器回调里面不允许申请内存吗？

gamerskyer

ThreadX定时器回调里面不允许申请内存吗？
版本：ThreadX 6.1.2
文件：txe_byte_allocate.c
位置：Line 167
现象：使用函数 tx_byte_allocate() 申请字节内存时，该函数会判断当前正在运行的线程是否为定时器的线程，如果不是则继续向下执行，否则就返回 TX_CALLER_ERROR 的错误，导致内存申请失败。

1. /**************************************************************************/
   
2. /*                                                                        */
   
3. /*       Copyright (c) Microsoft Corporation. All rights reserved.        */
   
4. /*                                                                        */
   
5. /*       This software is licensed under the Microsoft Software License   */
   
6. /*       Terms for Microsoft Azure RTOS. Full text of the license can be  */
   
7. /*       found in the LICENSE file at https://aka.ms/AzureRTOS_EULA       */
   
8. /*       and in the root directory of this software.                      */
   
9. /*                                                                        */
   
10. /**************************************************************************/
    
11. 
    
12. 
    
13. /**************************************************************************/
    
14. /**************************************************************************/
    
15. /**                                                                       */
    
16. /** ThreadX Component                                                     */
    
17. /**                                                                       */
    
18. /**   Byte Memory                                                         */
    
19. /**                                                                       */
    
20. /**************************************************************************/
    
21. /**************************************************************************/
    
22. 
    
23. #define TX_SOURCE_CODE
    
24. 
    
25. 
    
26. /* Include necessary system files.  */
    
27. 
    
28. #include "tx_api.h"
    
29. #include "tx_initialize.h"
    
30. #include "tx_thread.h"
    
31. #include "tx_timer.h"
    
32. #include "tx_byte_pool.h"
    
33. 
    
34. 
    
35. /**************************************************************************/
    
36. /*                                                                        */
    
37. /*  FUNCTION                                               RELEASE        */
    
38. /*                                                                        */
    
39. /*    _txe_byte_allocate                                  PORTABLE C      */
    
40. /*                                                           6.1          */
    
41. /*  AUTHOR                                                                */
    
42. /*                                                                        */
    
43. /*    William E. Lamie, Microsoft Corporation                             */
    
44. /*                                                                        */
    
45. /*  DESCRIPTION                                                           */
    
46. /*                                                                        */
    
47. /*    This function checks for errors in allocate bytes function call.    */
    
48. /*                                                                        */
    
49. /*  INPUT                                                                 */
    
50. /*                                                                        */
    
51. /*    pool_ptr                          Pointer to pool control block     */
    
52. /*    memory_ptr                        Pointer to place allocated bytes  */
    
53. /*                                        pointer                         */
    
54. /*    memory_size                       Number of bytes to allocate       */
    
55. /*    wait_option                       Suspension option                 */
    
56. /*                                                                        */
    
57. /*  OUTPUT                                                                */
    
58. /*                                                                        */
    
59. /*    TX_POOL_ERROR                     Invalid memory pool pointer       */
    
60. /*    TX_PTR_ERROR                      Invalid destination pointer       */
    
61. /*    TX_WAIT_ERROR                     Invalid wait option               */
    
62. /*    TX_CALLER_ERROR                   Invalid caller of this function   */
    
63. /*    TX_SIZE_ERROR                     Invalid size of memory request    */
    
64. /*    status                            Actual completion status          */
    
65. /*                                                                        */
    
66. /*  CALLS                                                                 */
    
67. /*                                                                        */
    
68. /*    _tx_byte_allocate                 Actual byte allocate function     */
    
69. /*                                                                        */
    
70. /*  CALLED BY                                                             */
    
71. /*                                                                        */
    
72. /*    Application Code                                                    */
    
73. /*                                                                        */
    
74. /*  RELEASE HISTORY                                                       */
    
75. /*                                                                        */
    
76. /*    DATE              NAME                      DESCRIPTION             */
    
77. /*                                                                        */
    
78. /*  05-19-2020     William E. Lamie         Initial Version 6.0           */
    
79. /*  09-30-2020     Yuxin Zhou               Modified comment(s),          */
    
80. /*                                            resulting in version 6.1    */
    
81. /*                                                                        */
    
82. /**************************************************************************/
    
83. UINT  _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr,
    
84.                                     ULONG memory_size,  ULONG wait_option)
    
85. {
    
86. 
    
87. UINT            status;
    
88. #ifndef TX_TIMER_PROCESS_IN_ISR
    
89. TX_THREAD       *thread_ptr;
    
90. #endif
    
91. 
    
92. 
    
93.     /* Default status to success.  */
    
94.     status =  TX_SUCCESS;
    
95. 
    
96.     /* Check for an invalid byte pool pointer.  */
    
97.     if (pool_ptr == TX_NULL)
    
98.     {
    
99.         
    
100.         /* Byte pool pointer is invalid, return appropriate error code.  */
     
101.         status =  TX_POOL_ERROR;
     
102.     }
     
103.    
     
104.     /* Now check for invalid pool ID.  */
     
105.     else if  (pool_ptr -> tx_byte_pool_id != TX_BYTE_POOL_ID)
     
106.     {
     
107.         
     
108.         /* Byte pool pointer is invalid, return appropriate error code.  */
     
109.         status =  TX_POOL_ERROR;
     
110.     }
     
111. 
     
112.     /* Check for an invalid destination for return pointer.  */
     
113.     else if (memory_ptr == TX_NULL)
     
114.     {
     
115. 
     
116.         /* Null destination pointer, return appropriate error.  */
     
117.         status =  TX_PTR_ERROR;
     
118.     }
     
119. 
     
120.     /* Check for an invalid memory size.  */
     
121.     else if (memory_size == ((ULONG) 0))
     
122.     {
     
123. 
     
124.         /* Error in size, return appropriate error.  */
     
125.         status =  TX_SIZE_ERROR;
     
126.     }
     
127.    
     
128.     /* Determine if the size is greater than the pool size.  */
     
129.     else if (memory_size > pool_ptr -> tx_byte_pool_size)
     
130.     {
     
131. 
     
132.         /* Error in size, return appropriate error.  */
     
133.         status =  TX_SIZE_ERROR;
     
134.     }
     
135. 
     
136.     else
     
137.     {
     
138. 
     
139.         /* Check for a wait option error.  Only threads are allowed any form of
     
140.            suspension.  */
     
141.         if (wait_option != TX_NO_WAIT)
     
142.         {
     
143. 
     
144.             /* Is call from ISR or Initialization?  */
     
145.             if (TX_THREAD_GET_SYSTEM_STATE() != ((ULONG) 0))
     
146.             {
     
147.         
     
148.                 /* A non-thread is trying to suspend, return appropriate error code.  */
     
149.                 status =  TX_WAIT_ERROR;
     
150.             }
     
151.         }
     
152.     }
     
153. #ifndef TX_TIMER_PROCESS_IN_ISR
     
154.    
     
155.     /* Check for timer execution.  */
     
156.     if (status == TX_SUCCESS)
     
157.     {
     
158. 
     
159.         /* Pickup thread pointer.  */
     
160.         TX_THREAD_GET_CURRENT(thread_ptr)
     
161. 
     
162.         /* Check for invalid caller of this function.  First check for a calling thread.  */
     
163.         if (thread_ptr == &_tx_timer_thread)
     
164.         {
     
165. 
     
166.             /* Invalid caller of this function, return appropriate error code.  */
     
167.             status =  TX_CALLER_ERROR;
     
168.         }
     
169.     }
     
170. #endif
     
171. 
     
172.     /* Is everything still okay?  */
     
173.     if (status == TX_SUCCESS)
     
174.     {
     
175.    
     
176.         /* Check for interrupt call.  */
     
177.         if (TX_THREAD_GET_SYSTEM_STATE() != ((ULONG) 0))
     
178.         {
     
179.    
     
180.             /* Now, make sure the call is from an interrupt and not initialization.  */
     
181.             if (TX_THREAD_GET_SYSTEM_STATE() < TX_INITIALIZE_IN_PROGRESS)
     
182.             {
     
183.         
     
184.                 /* Invalid caller of this function, return appropriate error code.  */
     
185.                 status =  TX_CALLER_ERROR;
     
186.             }
     
187.         }
     
188.     }
     
189. 
     
190.     /* Determine if everything is okay.  */
     
191.     if (status == TX_SUCCESS)
     
192.     {
     
193. 
     
194.         /* Call actual byte memory allocate function.  */
     
195.         status =  _tx_byte_allocate(pool_ptr, memory_ptr, memory_size,  wait_option);
     
196.     }
     
197. 
     
198.     /* Return completion status.  */
     
199.     return(status);
     
200. }

复制代码

emwin

文档里写的允许在初始化和线程里使用，看代码也是。如果TIMER设的中断模式，就返回TX_CALLER_ERROR

emwin

中断里用tx_block_allocate()

eric2013

看代码是这个意思，不可以定时器组件回调调用，如果使能了#ifndef TX_TIMER_PROCESS_IN_ISR可以。

catro

应该是不用于在定时器回调函数里面阻塞。把wait_option设置成TX_NO_WAIT就可以调用了。

gamerskyer

谢谢各位大佬的回复，由于我之前经常在 FreeRTOS 的定时器回调里面申请不定长的内存，所以才有了这样的需求。
1. ThreadX 里面确实可以使用 tx_block_allocate() 来申请固定长度的内存，但是这样做无法满足我现在的需求，其实这也是我不理解的地方，按道理来说 tx_byte_allocate() 与  tx_block_allocate() 的基本框架应该是一致的。
2. ThreadX 里面如果定义了宏 TX_TIMER_PROCESS_IN_ISR 的话 ThreadX 就不会启用软件定时器线程，超时的回调函数都会在定时器中断里面执行，但是 tx_byte_allocate() 函数会在 185 行退出，错误代码还是 TX_CALLER_ERROR。
3. tx_byte_allocate() 函数的 wait_option 我一直用的就是 TX_NO_WAIT，应该和这个选项没关系吧。
Note:The performance of this service is a function of the block size and the amount of fragmentation in the pool. Hence, this service should not be used during time-critical threads of execution.
文档中说：不应在时间关键线程执行期间使用 tx_byte_allocate() 函数。
可能是官方认为申请不定长的内存会影响系统的实时性吧。
我现在只好新建一个线程，然后人为延时一个固定的时间，来模拟软件定时器的执行，变相地实现这种功能。

1. void app_thread_cb(ULONG thread_input)
   
2. {
   
3.         while (1) {
   
4.                 tx_thread_sleep(10);
   
5.                 app_timer_cb();
   
6.         }
   
7. }

复制代码

eric2013

gamerskyer 发表于 2020-12-29 13:58
谢谢各位大佬的回复，由于我之前经常在 FreeRTOS 的定时器回调里面申请不定长的内存，所以才有了这样的需求 ...

谢谢告知，回头我也测测。

三尺长剑

首先中断中不允许处理费时间的操作，而内存分配的时候会有锁来保护资源，如此一来申请内存就会有阻塞

血染风采2017

我也有这方面的需求，需要在回调函数中发布消息，而消息的内存是动态分配的，现象和你这边一样。还没想到一个好的办法解决。。。