ThreadX(五)------内存Memory

最新推荐文章于 2024-03-07 21:40:03 发布

heart-beats

最新推荐文章于 2024-03-07 21:40:03 发布

阅读量1.2k

点赞数

分类专栏： ThreadX RTOS 文章标签： stm32 操作系统单片机内存管理

本文链接：https://blog.csdn.net/qq_37555002/article/details/108173654

版权

ThreadX RTOS 专栏收录该内容

10 篇文章 18 订阅

订阅专栏

ThreadX内存管理

- API

API

tx_block_allocate
tx_block_pool_create
tx_block_pool_delete
tx_block_pool_info_get
tx_block_pool_performance_info_get
tx_block_pool_performance_system_info_get
tx_block_pool_prioritize
tx_block_release

tx_byte_allocate
tx_byte_pool_create
tx_byte_pool_delete
tx_byte_pool_info_get
tx_byte_pool_performance_info_get
tx_byte_pool_performance_system_info_get
tx_byte_pool_prioritize
tx_byte_release

tx_block_allocate

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

参数

pool_ptr 指向以前创建的内存块池的指针。
block_ptr 指向目标块指针的指针。成功分配时，分配的内存块的地址将放置在此参数点的位置。
wait_option 定义服务在没有可用的内存块时的行为方式。
等待选项的定义如下：

TX_NO_WAIT （0x0x0000000） - TX_NO_WAIT，无论它成功与否，都会立即从该服务返回。如果从非线程调用服务，则这是唯一有效的选项;例如，初始化、计时器或 ISR。
TX_WAIT_FOREVER （0xFFFF） - TX_WAIT_FOREVER，这将导致调用线程无限期挂起，直到内存块可用。
超时值（0x0000001 到 0xFFFFFFFE） - 选择数值（1-0xFFFFFFFE）指定在等待内存块时保持挂起计时器的最大数量。

返回值

TX_SUCCESS （0x00）成功的内存块分配。
TX_DELETED时，已删除内存块池（0x01）内存块池。
TX_NO_MEMORY （0x10）服务无法在指定时间内分配内存块以等待。
TX_WAIT_ABORTED （0x1A）挂起被另一个线程、计时器或 ISR 中止。
TX_POOL_ERROR （0x02）无效内存块池指针。
TX_WAIT_ERROR （0x04）在从非TX_NO_WAIT的呼叫上指定的等待选项（非线程）以外的等待选项。
TX_PTR_ERROR （0x03）到目标指针的无效指针。

tx_block_pool_create

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

参数

pool_ptr指向内存块池控件块的指针。
name_ptr指向内存块池的名称的指针。
block_size每个内存块中的字节数。
pool_start内存块池的起始地址。起始地址必须与 ULONG 数据类型的大小对齐。
pool_size内存块池可用的字节总数。

返回值

TX_SUCCESS （0x00）成功创建内存块池。
TX_POOL_ERROR （0x02）无效内存块池指针。指针为 NULL 或已创建池。
TX_PTR_ERROR （0x03）池的无效起始地址。
TX_CALLER_ERROR服务（0x13）无效调用方。
TX_SIZE_ERROR （0x05）池的大小无效。

tx_block_pool_delete

UINT tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr);

-参数

pool_ptr指向以前创建的内存块池的指针。

返回值

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

tx_block_release

UINT tx_block_release(VOID *block_ptr);

参数

block_ptr指向以前分配的内存块的指针。

返回值

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

tx_byte_allocate

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

参数

pool_ptr 指向以前创建的内存块池的指针。
memory_ptr 指向目标内存指针的指针。成功分配时，分配的内存区域的地址将放置在此参数指向的位置。
memory_size 请求的字节数。
wait_option 定义服务在可用内存不足时的行为方式。
等待选项的定义如下：

TX_NO_WAIT （0x00000000） - TX_NO_WAIT，无论它是否成功，都会立即从该服务返回。如果从初始化调用服务，这是唯一有效的选项。
TX_WAIT_FOREVER 0xFFFF） - TX_WAIT_FOREVER，这将导致调用线程无限期挂起，直到有足够的内存可用。
超时值（0x0000001 到 0xFFFFFE） - 选择数值（1-0xFFFFFFFE）指定在等待内存时保持挂起计时器刻度的最大数量。

返回值

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）请求的大小为零或大于池。
TX_WAIT_ERROR （0x04）在从非TX_NO_WAIT的呼叫上指定的等待选项（非线程）以外的等待选项。
TX_CALLER_ERROR服务（0x13）无效调用方。

tx_byte_pool_create

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

参数

pool_ptr指向内存池控件块的指针。
name_ptr指向内存池名称的指针。
pool_start内存池的起始地址。起始地址必须与 ULONG 数据类型的大小对齐。
pool_size可用于内存池的字节总数。

返回值

TX_SUCCESS （0x00）成功创建内存池。
TX_POOL_ERROR （0x02）无效内存池指针。指针为 NULL 或已创建池。
TX_PTR_ERROR （0x03）池的无效起始地址。
TX_SIZE_ERROR （0x05）池的大小无效。
TX_CALLER_ERROR服务（0x13）无效调用方。

tx_byte_pool_delete

UINT tx_byte_pool_delete(TX_BYTE_POOL *pool_ptr);

参数

pool_ptr指向以前创建的内存池的指针。

返回值

TX_SUCCESS （0x00）成功删除内存池。
TX_POOL_ERROR （0x02）无效内存池指针。
TX_CALLER_ERROR服务（0x13）无效调用方。

tx_byte_release

UINT tx_byte_release(VOID *memory_ptr);

参数

memory_ptr指向以前分配的内存区域的指针。

返回值

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

memory_demo

/*
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 * tracex_demo.c
 * Change Logs:
 * Date           Author       Notes
 * 2020年8月25日     	  henji      the first version
 */
	.......
	.......
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "tx_api.h"
/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
TX_THREAD my_thread_1;
TX_THREAD my_thread_2;
TX_THREAD trace_thread;
uint8_t pData[] = "=========ThreadX=========\n";
uint8_t pData1[] = "I am thread1 ";
uint8_t pData2[] = "I am thread2 ";


/*线程栈大小*/
#define DEMO_STACK_SIZE 1024
/*内存池总大小*/
#define DEMO_BYTE_POOL_SIZE 1024*5
/*内存块池总大小*/
#define DEMO_BLOCK_POOL_SIZE 100
/*内存字节池控制指针*/
TX_BYTE_POOL byte_pool_0;
/*内存块池控制指针*/
TX_BLOCK_POOL block_pool_0;
/* 指向内存的指针 */
UCHAR *memory_ptr;

/* Tracex使用 */
/*跟踪缓冲区的内存大小*/
#define trace_buffer_size 64000
/*要保留在跟踪注册表中的应用程序ThreadX对象的数量*/
#define registry_entries 40
UCHAR trace_buffer_start[trace_buffer_size];
UINT trace_status;
/* USER CODE END PV */
	.......
int main(void)
{
    .......
	/* USER CODE BEGIN 2 */

	tx_kernel_enter(); //threadx 入口

	/* USER CODE END 2 */
	while (1);
}

/* USER CODE BEGIN 4 */
void thread1_entry(ULONG entry_input)
{

	INT count = 0;
	uint8_t init_data[] = "start now";
	while (1)
	{
		if (count == 0)
		{
			HAL_UART_Transmit(&huart1, init_data, sizeof(init_data),
			HAL_MAX_DELAY);
		}
		else
		{
			HAL_UART_Transmit(&huart1, pData1, sizeof(pData1), HAL_MAX_DELAY);
		}
		count++;
		HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_7 | GPIO_PIN_8);
		tx_thread_sleep(30);
	}
}

void thread2_entry(ULONG entry_input)
{
	INT count = 0;
	while (1)
	{
		HAL_UART_Transmit(&huart1, pData2, sizeof(pData2), HAL_MAX_DELAY);
		if (count == 1)
		{
			/*分配一个内存块空间*/
			 tx_byte_allocate(&byte_pool_0,		   //内存池的指针
					 	 	  (VOID **)&memory_ptr,//指向目标内存指针的指针
							  DEMO_BLOCK_POOL_SIZE,//分配内存块区域
							  TX_NO_WAIT		   //无论它是否成功，都会立即从该服务返回
							  );
			 /*创建内存块*/
			 tx_block_pool_create(&block_pool_0, 	 //内存块池的指针
					 	 	 	 "block pool 0", 	 //内存块池名称
								 10,			 	 //每块大小
								 memory_ptr,     	 //指向目标内存指针的指针
								 DEMO_BLOCK_POOL_SIZE//内存块池总字节数
								 );
			 /*分配内存块*/
			 tx_block_allocate(&block_pool_0, //内存块池的指针
					  (VOID **)&memory_ptr,   //指向目标内存指针的指针
							   TX_NO_WAIT //  无论它成功与否，都会立即从该服务返回
			 	 	 	 	   );
			 /*释放*/
			 tx_block_release(memory_ptr);

		}
		count++;

		tx_thread_sleep(20);
	}
}

void trace_thread_input(ULONG entry_input)
{

	while (1)
	{
		/*使能追踪*/
		trace_status = tx_trace_enable(&trace_buffer_start, trace_buffer_size, registry_entries);
		if (trace_status == TX_SUCCESS)
		{
			; //使能成功
		}
		if (trace_status == TX_NOT_DONE)
		{
			; //在追踪
		}
		tx_thread_sleep(10);
	}
}


void tx_application_define(void *first_unused_memory)
{

	/* 追踪 */
	trace_status = tx_trace_enable(&trace_buffer_start, trace_buffer_size, registry_entries);
	/*创建一个内存池用于分配线程栈*/
	tx_byte_pool_create(&byte_pool_0, 		//内存池的指针
					"byte pool 0",		//名称
					first_unused_memory,//分配内存地址
					DEMO_BYTE_POOL_SIZE //分配内存池大小
					);

	/*分配一个栈空间用于trace*/
	 tx_byte_allocate(&byte_pool_0,		   //内存池的指针
			 	 	  (VOID **)&memory_ptr,//指向目标内存指针的指针
					  DEMO_STACK_SIZE,     //分配栈大小
					  TX_NO_WAIT		   //无论它是否成功，都会立即从该服务返回
					  );

	/*trace 线程*/
	tx_thread_create(&trace_thread,	//线程控制块指针
			"trace_thread",         //线程名字
			trace_thread_input,//线程入口函数
			0,               //线程入口参数
			memory_ptr,		 //线程的起始地址
			DEMO_STACK_SIZE, //内存区域大小K
			1,               //优先级2 (0~TX_MAX_PRIORITES-1)0  表示最高优先级
			1,               //禁用抢占的最高优先级
			TX_NO_TIME_SLICE,//时间切片值范围为 1 ~ 0xFFFF(TX_NO_TIME_SLICE = 0)
			TX_AUTO_START    //线程自动启动
			);

	/*分配一个栈空间用于线程1*/
	 tx_byte_allocate(&byte_pool_0,		   //内存池的指针
			 	 	  (VOID **)&memory_ptr,//指向目标内存指针的指针
					  DEMO_STACK_SIZE,     //分配栈大小
					  TX_NO_WAIT		   //无论它是否成功，都会立即从该服务返回
					  );

	/*创建线程1*/
	tx_thread_create(&my_thread_1,	//线程控制块指针
			"my_thread1",    //线程名字
			thread1_entry,   //线程入口函数
			0,				 //线程入口参数
			memory_ptr,		 //线程的起始地址
			DEMO_STACK_SIZE, //线程栈大小 K
			3,				 //优先级3  (0~TX_MAX_PRIORITES-1)0  表示最高优先级
			3,				 //禁用抢占的最高优先级
			TX_NO_TIME_SLICE,//时间切片值范围为 1 ~ 0xFFFF(TX_NO_TIME_SLICE = 0)
			TX_AUTO_START    //线程自动启动
			);

	/*分配一个栈空间用于线程2*/
	 tx_byte_allocate(&byte_pool_0,		   //内存池的指针
			 	 	  (VOID **)&memory_ptr,//指向目标内存指针的指针
					  DEMO_STACK_SIZE,     //分配栈大小
					  TX_NO_WAIT		   //无论它是否成功，都会立即从该服务返回
					  );
	/*线程2*/
	tx_thread_create(&my_thread_2,	//线程控制块指针
			"my_thread2",    //线程名字
			thread2_entry,   //线程入口函数
			0,				 //线程入口参数
			memory_ptr,      //线程的起始地址
			DEMO_STACK_SIZE, //线程栈大小 K
			2,               //优先级2 (0~TX_MAX_PRIORITES-1)0  表示最高优先级
			2,               //禁用抢占的最高优先级
			TX_NO_TIME_SLICE,//时间切片值范围为 1 ~ 0xFFFF(TX_NO_TIME_SLICE = 0)
			TX_AUTO_START    //线程自动启动
			);

}
/* USER CODE END 4 */

完

heart-beats

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadX(五)------内存Memory

ThreadX内存管理APItx_block_allocatetx_block_pool_createtx_block_pool_deletetx_block_releasetx_byte_allocatetx_byte_pool_createtx_byte_pool_deletetx_byte_releasememory_demoAPItx_block_allocatetx_block_pool_createtx_block_pool_deletetx_block_pool_info_get
复制链接

扫一扫