threadx学习笔记（4）内存管理

有一点点想CoCo你

于 2024-03-07 21:40:03 发布

阅读量1.7k

点赞数 56

文章标签：学习笔记

本文链接：https://blog.csdn.net/m0_71240643/article/details/136528815

版权

内容参考：

ThreadX学习（4）——内存管理_tx_pool_error-CSDN博客

在此基础上添加实现代码。

ThreadX中的内存分配有两种方法：内存字节池和内存块池。

内存字节池：

1.tx_byte_pool_create

TX_BYTE_POOL my_pool;//先定义一个内存字节池

UINT  tx_byte_pool_create(  TX_BYTE_POOL *pool_ptr, 
							CHAR *name_ptr,  
							VOID *pool_start, 
							ULONG pool_size)

第 1 个参数 pool_ptr 是内存字节池控制块指针。
第 2 个参数 name_ptr 是字节池名。
第 3 个参数 pool_start 是字节池的首地址。
第 4 个参数 pool_size 是字节池的长度。

在示例代码中创造内存字节池，再把返回值打印出来，可以看到串口打印结果为0，即内存字节池创造成功。

 VOID tx_application_define(void  *first_unused_memory)
{
	UINT aa= tx_byte_pool_create(&byte_POOL_0,"bytepool 0",first_unused_memory,256);
	char buffer[256];
	snprintf(buffer,sizeof(buffer),"%u\n",aa);
	HAL_UART_Transmit(&huart1, (uint8_t *)buffer, strlen(buffer), HAL_MAX_DELAY);
	/* Create the main thread.  */
  tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
            thread_0_stack, DEMO_STACK_SIZE, 
            1, 1, 10, TX_AUTO_START);
	tx_thread_create(&thread_1, "Thread 1", thread_1_entry, 0,
                     thread_1_stack, DEMO_STACK_SIZE,
                     2, 2, TX_NO_TIME_SLICE, TX_AUTO_START);
}

2.tx_byte_allocate

分配内存字节池函数

一般写在线程内部，用来给线程分配内存字节池。

UINT  tx_byte_allocate( TX_BYTE_POOL *pool_ptr, 
						VOID **memory_ptr, 
						ULONG memory_size,  
						ULONG wait_option)

第 1 个参数 pool_ptr 是内存字节池控制块指针。
第 2 个参数 memory_ptr 是字节池分配空间首地址的指针。
第 3 个参数 memory_size是字节池分配空间大小。
第 4 个参数 wait_option是字节池分配等待选项：
TX_NO_WAIT：不等待，直接返回结果。
TX_WAIT_FOREVER：一直等待直到获取字节池空间。
timeout value：设置等待时间（时钟脉冲）。
返回值：
TX_SUCCESS（0x00）成功分配字节池。
TX_DELETED: (0x01)线程挂起时内存池被删除。
TX_NO_MEMORY: (0x10) 无法在指定的等待时间内分配内存。
TX_WAIT_ABORTED: (0x1A)挂起被另一个线程、计时器或ISR中止。
TX_POOL_ERROR:(0x02)无效的内存池指针。
TX_PTR_ERROR:(0x03)指向目标指针的指针无效。
TX_SIZE_ERROR: (0X05)请求的大小是0或大于池的总大小。
TX_WAIT_ERROR: (0x04)在非线程调用时指定了TX_NO_WAIT以外的等待选项。
TX_CALLER_ERROR:(0x13)无效的服务调用者。

下面的示例代码，给线程0申请了一个32字节大小的内存空间，申请后，通过调用tx_byte_pool_info_get函数得到内存池信息。可以看到256字节大小的内存池变成了208字节大小少的4字节是内存管理开销。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

		VOID *memory_ptr;
		char *name;
		ULONG available_bytes;
		ULONG fragments;
		TX_THREAD *first_suspended;
		ULONG suspended_count; 
		TX_BYTE_POOL *next_pool;
	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT byteask= tx_byte_allocate(&byte_POOL_0,&memory_ptr,32,TX_NO_WAIT);
		snprintf(buffer1, sizeof(buffer1), "%u\n",byteask);
		HAL_UART_Transmit(&huart1,(uint8_t *)buffer1,strlen(buffer1),HAL_MAX_DELAY);
		
		tx_byte_pool_info_get(&byte_POOL_0,&name,&available_bytes,&fragments,&first_suspended,&suspended_count,&next_pool);
		snprintf(buffer1, sizeof(buffer1), 
             "bytes Name: %s\navailable_bytes: %lu\nfragments: %lu\nsuspended_count: %lu\nnext_pool: %p\n",
             name,available_bytes,fragments,suspended_count,next_pool);
    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
}

3.tx_byte_pool_delete

UINT  tx_byte_pool_delete(TX_BYTE_POOL *pool_ptr)

第 1 个参数 pool_ptr 是内存字节池控制块指针。
返回值：
- TX_SUCCESS（0x00）成功删除字节池。
- TX_POOL_ERROR:(0x02)无效的内存池指针。
- TX_CALLER_ERROR:(0x13)无效的服务调用者。

和互斥锁类似，删除内存字节池后，字节池挂起的所有线程都将恢复，并接收TX_DELETED返回状态。

示例代码展示了如何删除之前创建好的内存字节池，根据串口打印结果显示，删除成功。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT aa=	tx_byte_pool_delete(&byte_POOL_0);
		snprintf(buffer1, sizeof(buffer1),"%u\n" ,aa);
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
}

4.tx_byte_pool_info_get

关于这部分的展示，已经在内存分配函数中展示过了。

UINT  tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, 
							CHAR **name, 
							ULONG *available_bytes, 
							ULONG *fragments, 
							TX_THREAD **first_suspended, 
							ULONG *suspended_count, 
							TX_BYTE_POOL **next_pool)

第 1 个参数 pool_ptr 是内存字节池控制块指针。
第 2 个参数 name 是字节池名字符串，获取后存储的指针。
第 3 个参数 available_bytes 是可用字节数，获取后存储的指针。
第 4 个参数 fragments 是碎片数量，获取后存储的指针。
第 5 个参数 first_suspended 是等待该字节池的第一个线程TCB指针，获取后存储的指针。
第 6 个参数 suspended_count 是等待该字节池的线程数，获取后存储的指针。
第 7 个参数 next_pool 是字节池列表的下一个字节池控制块指针，获取后存储的指针。

返回值：

TX_SUCCESS（0x00）成功获取字节池信息。
TX_POOL_ERROR:(0x02)无效的内存池指针。

5.tx_byte_pool_prioritize

UINT  tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr)

字节池挂起列表的最高优先级线程置队头

返回值：

TX_SUCCESS（0x00）成功或挂起列表为空。

TX_POOL_ERROR:(0x02)无效的内存池指针。

示例代码在线程0中调用了函数tx_byte_pool_prioritize，根据串口打印结果，可以看到，函数调用成功。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT aa=	tx_byte_pool_prioritize(&byte_POOL_0);
		snprintf(buffer1, sizeof(buffer1),"%u\n" ,aa);
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
}

6.tx_byte_release

UINT  tx_byte_release(VOID *memory_ptr)

字节池释放空间

第 1 个参数 memory_ptr 是要释放的空间首地址。

返回值：

TX_SUCCESS（0x00）成功释放。
TX_PTR_ERROR:(0x03)无效的内存区域指针。
TX_CALLER_ERROR:(0x13)无效的服务调用者。

下列代码先实现了内存分配，然后打印内存池信息，再内存释放，再次打印内存池信息，可以看到两次内存池的内存大小产生了变化。之所以两次内存大小之差是30而不是32，是因为在实际应用中，系统可能会在分配内存时，额外地使用一些字节来保存内部的控制信息。这些额外的字节通常用于维护内存池和内存块之间的关系，以及记录已分配和未分配的内存块等信息。

tx_byte_release将先前分配的内存区域释放，挂起列表按顺序开始分配，直至内存池空间不足或挂起列表为空。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

		VOID *memory_ptr;
		char *name;
		ULONG available_bytes;
		ULONG fragments;
		TX_THREAD *first_suspended;
		ULONG suspended_count; 
		TX_BYTE_POOL *next_pool;
	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT byteask= tx_byte_allocate(&byte_POOL_0,&memory_ptr,32,TX_NO_WAIT);
		snprintf(buffer1, sizeof(buffer1), "%u\n",byteask);
		HAL_UART_Transmit(&huart1,(uint8_t *)buffer1,strlen(buffer1),HAL_MAX_DELAY);
		
		tx_byte_pool_info_get(&byte_POOL_0,&name,&available_bytes,&fragments,&first_suspended,&suspended_count,&next_pool);
		snprintf(buffer1, sizeof(buffer1), 
             "bytes Name: %s\navailable_bytes: %lu\nfragments: %lu\nsuspended_count: %lu\nnext_pool: %p\n",
             name,available_bytes,fragments,suspended_count,next_pool);
    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT byterelease= tx_byte_release(memory_ptr);
		snprintf(buffer1, sizeof(buffer1), "%u\n",byterelease);
		HAL_UART_Transmit(&huart1,(uint8_t *)buffer1,strlen(buffer1),HAL_MAX_DELAY);
		
		tx_byte_pool_info_get(&byte_POOL_0,&name,&available_bytes,&fragments,&first_suspended,&suspended_count,&next_pool);
		snprintf(buffer1, sizeof(buffer1), 
             "bytes Name: %s\navailable_bytes: %lu\nfragments: %lu\nsuspended_count: %lu\nnext_pool: %p\n",
             name,available_bytes,fragments,suspended_count,next_pool);
    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
}

内存块池：

1.tx_block_pool_create

TX_BLOCK_POOL my_pool;//先定义一个内存块池

UINT  tx_block_pool_create( TX_BLOCK_POOL *pool_ptr, 
							CHAR *name_ptr, 
							ULONG block_size,
							VOID *pool_start, 
							ULONG pool_size)

创建内存字节池：

第 1 个参数 pool_ptr 是内存块池控制块指针。
第 2 个参数 name_ptr 是内存块池名。
第 3 个参数 block_size 是单个内存块的大小。
第 4 个参数 pool_start 是内存块池的首地址。
第 5 个参数 pool_size 是内存块池的总大小。

返回值：

TX_SUCCESS（0x00）成功创建内存块池。
TX_POOL_ERROR:(0x02)无效的内存块池指针。要么指针是NULL，要么池已经创建。
TX_PTR_ERROR: (0x03)无效的池起始地址。
TX_SIZE_ERROR: (0x05)池大小无效。
TX_CALLER_ERROR:(0x13)无效的服务调用者。

示例代码展示如何创建一个内存块池，内存块池的起始指针应该是一个独立的、未被其他内存池使用的地址。串口打印显示创建成功。

VOID tx_application_define(void  *first_unused_memory)
{
	UINT aa= tx_byte_pool_create(&byte_POOL_0,"bytepool 0",first_unused_memory,256);
	char buffer[256];
	snprintf(buffer,sizeof(buffer),"%u\n",aa);
	HAL_UART_Transmit(&huart1, (uint8_t *)buffer, strlen(buffer), HAL_MAX_DELAY);
	UINT bb= tx_block_pool_create(&my_pool,"blockpool 0",32,(UCHAR*)first_unused_memory+256,512);
	snprintf(buffer,sizeof(buffer),"%u\n",bb);
	HAL_UART_Transmit(&huart1, (uint8_t *)buffer, strlen(buffer), HAL_MAX_DELAY);
  tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
            thread_0_stack, DEMO_STACK_SIZE, 
            1, 1, 10, TX_AUTO_START);
	tx_thread_create(&thread_1, "Thread 1", thread_1_entry, 0,
                     thread_1_stack, DEMO_STACK_SIZE,
                     2, 2, TX_NO_TIME_SLICE, TX_AUTO_START);
}

2.tx_block_allocate

UINT  tx_block_allocate(TX_BLOCK_POOL *pool_ptr, 
						VOID **block_ptr, 
						ULONG wait_option)

分配内存块：

第 1 个参数 pool_ptr 是内存块池控制块指针。
第 2 个参数 block_ptr 是分配得到的内存块首地址的指针，需要提前定义。
第 3 个参数 wait_option 是内存块池分配等待选项：
TX_NO_WAIT：不等待，直接返回结果。
TX_WAIT_FOREVER：一直等待直到获取内存块。
timeout value：设置等待时间（时钟脉冲）。
返回值：
TX_SUCCESS（0x00）成功分配。
TX_DELETED: (0x01)线程挂起时内存块池被删除。
TX_NO_MEMORY: (0x10) 无法在指定的等待时间内分配内存块。
TX_WAIT_ABORTED: (0x1A)挂起被另一个线程、定时器或ISR中止。
TX_POOL_ERROR:(0x02)无效的内存块池指针。
TX_PTR_ERROR:(0x03)无效的分配指针。
TX_WAIT_ERROR: (0x04)在非线程调用时指定了TX_NO_WAIT以外的等待选项。

在线程0中先分配内存块，再打印内存块池信息，再释放内存块，打印内存块池信息，根据串口打印结果显示，内存块分配成功，内存块释放成功。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

		VOID *memory_ptr;
		char *name;
		ULONG available_blocks;
		ULONG total_blocks;
		TX_THREAD *first_suspended;
		ULONG suspended_count; 
		TX_BLOCK_POOL *next_pool;
	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT byteask= tx_block_allocate(&my_pool,&memory_ptr,TX_NO_WAIT);
		snprintf(buffer1, sizeof(buffer1), "%u\n",byteask);
		HAL_UART_Transmit(&huart1,(uint8_t *)buffer1,strlen(buffer1),HAL_MAX_DELAY);
		
		tx_block_pool_info_get(&my_pool,&name,&available_blocks,&total_blocks,&first_suspended,&suspended_count,&next_pool);
		snprintf(buffer1, sizeof(buffer1), 
             "bytes Name: %s\navailable_bytes: %lu\nfragments: %lu\nsuspended_count: %lu\nnext_pool: %p\n",
             name,available_blocks,total_blocks,suspended_count,next_pool);
    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT byterelease= tx_block_release(memory_ptr);
		snprintf(buffer1, sizeof(buffer1), "%u\n",byterelease);
		HAL_UART_Transmit(&huart1,(uint8_t *)buffer1,strlen(buffer1),HAL_MAX_DELAY);
		
		tx_block_pool_info_get(&my_pool,&name,&available_blocks,&total_blocks,&first_suspended,&suspended_count,&next_pool);
		snprintf(buffer1, sizeof(buffer1), 
             "bytes Name: %s\navailable_bytes: %lu\nfragments: %lu\nsuspended_count: %lu\nnext_pool: %p\n",
             name,available_blocks,total_blocks,suspended_count,next_pool);
    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
}

3.tx_block_pool_info_get

UINT  tx_block_pool_info_get(	TX_BLOCK_POOL *pool_ptr, 
								CHAR **name, 
								ULONG *available_blocks, 
								ULONG *total_blocks, 
								TX_THREAD **first_suspended, 
								ULONG *suspended_count, 
								TX_BLOCK_POOL **next_pool)

获取内存块池信息：

第 1 个参数 pool_ptr 是内存块池控制块指针。
第 2 个参数 name 是内存块池名字符串，获取后存储的指针。
第 3 个参数 available_blocks 是可用内存块数，获取后存储的指针。
第 4 个参数 total_blocks 是内存块总数，获取后存储的指针。
第 5 个参数 first_suspended 是等待该内存块池的第一个线程TCB指针，获取后存储的指针。
第 6 个参数 suspended_count 是等待该内存块池的线程数，获取后存储的指针。
第 7 个参数 next_pool 是内存块池列表的下一个内存块池控制块指针，获取后存储的指针。

返回值：

TX_SUCCESS（0x00）成功获取内存块池信息。
TX_POOL_ERROR:(0x02)无效的内存块池指针。

相关示例代码再内存块分配函数中已经涉及

4.tx_block_release

UINT  tx_block_release(VOID *memory_ptr)

内存块释放：

第 1 个参数 memory_ptr 是要释放内存块首地址。

返回值：

TX_SUCCESS（0x00）成功释放。
TX_PTR_ERROR（0x03）无效的内存块指针。

相关示例代码再内存块分配函数中已经涉及

5. tx_block_pool_delete

UINT  tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr)

删除内存块池：

第 1 个参数 pool_ptr 是内存块池控制块指针。

返回值：

TX_SUCCESS（0x00）成功删除内存块池。
TX_POOL_ERROR:(0x02)无效的内存块池指针。
TX_CALLER_ERROR:(0x13)无效的服务调用者。

删除之前创建好的内存块池。根据串口打印的结果可以看到删除成功。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;

		VOID *memory_ptr;
		char *name;
		ULONG available_blocks;
		ULONG total_blocks;
		TX_THREAD *first_suspended;
		ULONG suspended_count; 
		TX_BLOCK_POOL *next_pool;
	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT aa=	tx_block_pool_delete(&my_pool);
		snprintf(buffer1, sizeof(buffer1),"%u\n" ,aa);
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
}

6.tx_block_pool_prioritize

UINT  tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr)

内存块池挂起列表的最高优先级线程置队头：

第 1 个参数 pool_ptr 是内存块池控制块指针。

返回值：

TX_SUCCESS（0x00）成功或挂起列表为空。
TX_POOL_ERROR:(0x02)无效的内存块池指针。

示例代码在线程0中调用了函数tx_block_pool_prioritize，根据串口打印结果，可以看到，函数调用成功。

void    thread_0_entry(ULONG thread_input)
	//线程,串口发送数据
{
		TX_THREAD *thread_ptr;
    CHAR *name_ptr;
    UINT state;
    ULONG run_count;
    UINT priority;
    UINT preemption_threshold;
    ULONG time_slice;
    UINT suspension_count;
    TX_THREAD *next_thread;
    TX_THREAD *previous_thread;
	
    // 缓冲区用于格式化输出字符串
    char buffer1[256];

    // 获取当前线程的指针
    thread_ptr = tx_thread_identify();

    // 获取当前线程信息
    tx_thread_info_get(thread_ptr, &name_ptr, &state, &run_count, &priority, &preemption_threshold,
                       &time_slice, &next_thread, &previous_thread);

    // 格式化线程信息为字符串
    snprintf(buffer1, sizeof(buffer1), 
             "Thread Name: %s\nState: %u\nRun Count: %lu\nPriority: %u\nPreemption Threshold: %u\nTime Slice: %lu\nSuspension Count: %u\n",
             name_ptr, state, run_count, priority, preemption_threshold, time_slice, suspension_count);

    // 通过UART发送线程信息
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		
		UINT aa=	tx_block_pool_prioritize(&my_pool);
		snprintf(buffer1, sizeof(buffer1),"%u\n" ,aa);
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
		UINT bb=	tx_block_pool_delete(&my_pool);
		snprintf(buffer1, sizeof(buffer1),"%u\n" ,bb);
		HAL_UART_Transmit(&huart1, (uint8_t *)buffer1, strlen(buffer1), HAL_MAX_DELAY);
}

有一点点想CoCo你

关注

56
点赞
踩
52

收藏

觉得还不错? 一键收藏
0
评论
threadx学习笔记（4）内存管理

下列代码先实现了内存分配，然后打印内存池信息，再内存释放，再次打印内存池信息，可以看到两次内存池的内存大小产生了变化。下面的示例代码，给线程0申请了一个32字节大小的内存空间，申请后，通过调用tx_byte_pool_info_get函数得到内存池信息。在线程0中先分配内存块，再打印内存块池信息，再释放内存块，打印内存块池信息，根据串口打印结果显示，内存块分配成功，内存块释放成功。示例代码在线程0中调用了函数tx_byte_pool_prioritize，根据串口打印结果，可以看到，函数调用成功。
复制链接

扫一扫