threadx碰到一段代码没有懂，希望各位大佬能帮忙指导一下

zjjjjj

在观看threadx源码时，碰到一段代码没有懂，希望各位大佬能帮忙指导一下。    RSEG    FREE_MEM:DATA
    PUBLIC  __tx_free_memory_start
__tx_free_memory_start
    DS32    4
上面部分代码没有看懂，首先RSEG    FREE_MEM:DATA是定义一个数据段；但是含义是未使用内存起始地址。数据段中不是还有全局变量和静态变量么？
按照我的想法这个应该定义到链接文件的.bss段以后呀，类似于如下：
[color=rgb(0, 153, 0) !important].bss : { *([color=rgb(0, 153, 0) !important].bss) }
.align32
__tx_free_memory_start = .
希望大佬们帮忙解释一下，感谢感谢（我使用的是IAR）

eric2013

看了下map文件，ThreadX这么定义不对，要放到bss末尾
这么定义是个bug。

eric2013

解决办法比较简单，设置下IAR的ICF的文件

place in RAM_region    { last section FREE_MEM};

zjjjjj

eric2013 发表于 2021-5-11 08:38
解决办法比较简单，设置下IAR的ICF的文件

place in RAM_region    { last section FREE_MEM};

感谢感谢，我找例程发现这个参数并没有使用，我自己也没想到这个参数可以使用的场景，在使用内存时，直接分配或者直接用静态、全局，感觉不需要用这个first_unused_memory，可不可以举例一下？

see-flying

Keil的工程也变成这样了 _tx_initialize_unused_memory 也不在内存最后的位置了，thread_0_stack~thread_5_stack的内存地址也在这个后面。最早的threadx版本都是用_tx_initialize_unused_memory地址来一块一块的增加的，分配给每个线程或者消息队列等。demo例程里直接把thread_0_stack~thread_5_stack等定义成全局数组了，没有使用_tx_initialize_unused_memory地址。在这个函数中tx_application_define(void *first_unused_memory)传递进去的参数都没使用。

eric2013

zjjjjj 发表于 2021-5-11 08:55
感谢感谢，我找例程发现这个参数并没有使用，我自己也没想到这个参数可以使用的场景，在使用内存时，直接 ...

对，没有使用这个，并不觉得方便。

官方的玩法是这样：

1. /* Define what the initial system looks like.  */
   
2. 
   
3. void    tx_application_define(void *first_unused_memory)
   
4. {
   
5. 
   
6. CHAR    *pointer = TX_NULL;
   
7. 
   
8. 
   
9.     /* Create a byte memory pool from which to allocate the thread stacks.  */
   
10.     tx_byte_pool_create(&byte_pool_0, "byte pool 0", memory_area, DEMO_BYTE_POOL_SIZE);
    
11. 
    
12.     /* Put system definition stuff in here, e.g. thread creates and other assorted
    
13.        create information.  */
    
14. 
    
15.     /* Allocate the stack for thread 0.  */
    
16.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
17. 
    
18.     /* Create the main thread.  */
    
19.     tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
    
20.             pointer, DEMO_STACK_SIZE,
    
21.             1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
    
22. 
    
23. 
    
24.     /* Allocate the stack for thread 1.  */
    
25.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
26. 
    
27.     /* Create threads 1 and 2. These threads pass information through a ThreadX
    
28.        message queue.  It is also interesting to note that these threads have a time
    
29.        slice.  */
    
30.     tx_thread_create(&thread_1, "thread 1", thread_1_entry, 1,  
    
31.             pointer, DEMO_STACK_SIZE,
    
32.             16, 16, 4, TX_AUTO_START);
    
33. 
    
34.     /* Allocate the stack for thread 2.  */
    
35.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
36. 
    
37.     tx_thread_create(&thread_2, "thread 2", thread_2_entry, 2,  
    
38.             pointer, DEMO_STACK_SIZE,
    
39.             16, 16, 4, TX_AUTO_START);
    
40. 
    
41.     /* Allocate the stack for thread 3.  */
    
42.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
43. 
    
44.     /* Create threads 3 and 4.  These threads compete for a ThreadX counting semaphore.  
    
45.        An interesting thing here is that both threads share the same instruction area.  */
    
46.     tx_thread_create(&thread_3, "thread 3", thread_3_and_4_entry, 3,  
    
47.             pointer, DEMO_STACK_SIZE,
    
48.             8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
    
49. 
    
50.     /* Allocate the stack for thread 4.  */
    
51.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
52. 
    
53.     tx_thread_create(&thread_4, "thread 4", thread_3_and_4_entry, 4,  
    
54.             pointer, DEMO_STACK_SIZE,
    
55.             8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
    
56. 
    
57.     /* Allocate the stack for thread 5.  */
    
58.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
59. 
    
60.     /* Create thread 5.  This thread simply pends on an event flag which will be set
    
61.        by thread_0.  */
    
62.     tx_thread_create(&thread_5, "thread 5", thread_5_entry, 5,  
    
63.             pointer, DEMO_STACK_SIZE,
    
64.             4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
    
65. 
    
66.     /* Allocate the stack for thread 6.  */
    
67.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
68. 
    
69.     /* Create threads 6 and 7.  These threads compete for a ThreadX mutex.  */
    
70.     tx_thread_create(&thread_6, "thread 6", thread_6_and_7_entry, 6,  
    
71.             pointer, DEMO_STACK_SIZE,
    
72.             8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
    
73. 
    
74.     /* Allocate the stack for thread 7.  */
    
75.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
    
76. 
    
77.     tx_thread_create(&thread_7, "thread 7", thread_6_and_7_entry, 7,  
    
78.             pointer, DEMO_STACK_SIZE,
    
79.             8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
    
80. 
    
81.     /* Allocate the message queue.  */
    
82.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_QUEUE_SIZE*sizeof(ULONG), TX_NO_WAIT);
    
83. 
    
84.     /* Create the message queue shared by threads 1 and 2.  */
    
85.     tx_queue_create(&queue_0, "queue 0", TX_1_ULONG, pointer, DEMO_QUEUE_SIZE*sizeof(ULONG));
    
86. 
    
87.     /* Create the semaphore used by threads 3 and 4.  */
    
88.     tx_semaphore_create(&semaphore_0, "semaphore 0", 1);
    
89. 
    
90.     /* Create the event flags group used by threads 1 and 5.  */
    
91.     tx_event_flags_create(&event_flags_0, "event flags 0");
    
92. 
    
93.     /* Create the mutex used by thread 6 and 7 without priority inheritance.  */
    
94.     tx_mutex_create(&mutex_0, "mutex 0", TX_NO_INHERIT);
    
95. 
    
96.     /* Allocate the memory for a small block pool.  */
    
97.     tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_BLOCK_POOL_SIZE, TX_NO_WAIT);
    
98. 
    
99.     /* Create a block memory pool to allocate a message buffer from.  */
    
100.     tx_block_pool_create(&block_pool_0, "block pool 0", sizeof(ULONG), pointer, DEMO_BLOCK_POOL_SIZE);
     
101. 
     
102.     /* Allocate a block and release the block memory.  */
     
103.     tx_block_allocate(&block_pool_0, (VOID **) &pointer, TX_NO_WAIT);
     
104. 
     
105.     /* Release the block back to the pool.  */
     
106.     tx_block_release(pointer);
     
107. }

复制代码