TCM SRAM等五块内存的使用和动态分配

配置sct文件
内存使用
动态内存分配
- rtx_lib.h
- rtx_memory.c
- main.c

配置sct文件

LR_IROM1 0x08000000 0x00200000 { ; load region size_regionER_IROM1 0x08000000 0x00200000 { ; load address = execution address*.o (RESET, +First)*(InRoot$$Sections).ANY (+RO)}; RW data - 128KB DTCMRW_IRAM1 0x20000000 0x00020000 { .ANY (+RW +ZI)}; RW data - 512KB AXI SRAMRW_IRAM2 0x24000000 0x00080000 { *(.RAM_D1) }; RW data - 128KB SRAM1(0x30000000) + 128KB SRAM2(0x3002 0000) + 32KB SRAM3(0x30040000)RW_IRAM3 0x30000000 0x00048000 { *(.RAM_D2)}; RW data - 64KB SRAM4(0x38000000)RW_IRAM4 0x38000000 0x00010000 { *(.RAM_D3)}
}

在这里插入图片描述

内存使用

/* 定义在 512KB AXI SRAM 里面的变量 */
__attribute__((section (".RAM_D1"))) uint32_t AXISRAMBuf[10];
__attribute__((section (".RAM_D1"))) uint16_t AXISRAMCount;
/* 定义在 128KB SRAM1(0x30000000) + 128KB SRAM2(0x30020000) + 32KB SRAM3(0x30040000)里面的变量 */
__attribute__((section (".RAM_D2"))) uint32_t D2SRAMBuf[10];
__attribute__((section (".RAM_D2"))) uint16_t D2SRAMount;
/* 定义在 64KB SRAM4(0x38000000)里面的变量 */
__attribute__((section (".RAM_D3"))) uint32_t D3SRAMBuf[10];
__attribute__((section (".RAM_D3"))) uint16_t D3SRAMCount;AXISRAMBuf[0] = AXISRAMCount++;
AXISRAMBuf[5] = AXISRAMCount++;
AXISRAMBuf[9] = AXISRAMCount++;D2SRAMBuf[0] = D2SRAMount++;
D2SRAMBuf[5] = D2SRAMount++;
D2SRAMBuf[9] = D2SRAMount++;D3SRAMBuf[0] = D3SRAMCount++;
D3SRAMBuf[5] = D3SRAMCount++;
D3SRAMBuf[9] = D3SRAMCount++;

动态内存分配

rtx_lib.h

#ifndef RTX_LIB_H_
#define RTX_LIB_H_#include <string.h>
#include <stdint.h>
#include "stm32h7xx.h"//  Memory Pool Header structure
typedef struct {uint32_t size;                // Memory Pool sizeuint32_t used;                // Used Memory
} mem_head_t;//  Memory Block Header structure
typedef struct mem_block_s {struct mem_block_s *next;     // Next Memory Block in listuint32_t            info;     // Block Info or max used Memory (in last block)
} mem_block_t;//  Memory Block Info: Length = <31:2>:'00', Type = <1:0>
#define MB_INFO_LEN_MASK        0xFFFFFFFCU     // Length mask
#define MB_INFO_TYPE_MASK       0x00000003U     // Type mask//  Memory Head Pointer
__STATIC_INLINE mem_head_t *MemHeadPtr (void *mem) {//lint -e{9079} -e{9087} "conversion from pointer to void to pointer to other type" [MISRA Note 6]return ((mem_head_t *)mem);
}//  Memory Block Pointer
__STATIC_INLINE mem_block_t *MemBlockPtr (void *mem, uint32_t offset) {uint32_t     addr;mem_block_t *ptr;//lint --e{923} --e{9078} "cast between pointer and unsigned int" [MISRA Note 8]addr = (uint32_t)mem + offset;ptr  = (mem_block_t *)addr;return ptr;
}//  ==== Library functions ====// Memory Heap Library functions
extern uint32_t osRtxMemoryInit (void *mem, uint32_t size);
extern void    *osRtxMemoryAlloc(void *mem, uint32_t size, uint32_t type);
extern uint32_t osRtxMemoryFree (void *mem, void *block);#endif  // RTX_LIB_H_

rtx_memory.c

#include "rtx_lib.h"//  ==== Library functions ====/// Initialize Memory Pool with variable block size.
/// \param[in]  mem             pointer to memory pool.
/// \param[in]  size            size of a memory pool in bytes.
/// \return 1 - success, 0 - failure.
__WEAK uint32_t osRtxMemoryInit (void *mem, uint32_t size) {mem_head_t  *head;mem_block_t *ptr;// Check parameters//lint -e{923} "cast from pointer to unsigned int" [MISRA Note 7]if ((mem == NULL) || (((uint32_t)mem & 7U) != 0U) || ((size & 7U) != 0U) ||(size < (sizeof(mem_head_t) + (2U*sizeof(mem_block_t))))) {//EvrRtxMemoryInit(mem, size, 0U);//lint -e{904} "Return statement before end of function" [MISRA Note 1]return 0U;}// Initialize memory pool headerhead = MemHeadPtr(mem);head->size = size;head->used = sizeof(mem_head_t) + sizeof(mem_block_t);// Initialize first and last block headerptr = MemBlockPtr(mem, sizeof(mem_head_t));ptr->next = MemBlockPtr(mem, size - sizeof(mem_block_t));ptr->next->next = NULL;ptr->next->info = sizeof(mem_head_t) + sizeof(mem_block_t);ptr->info = 0U;//EvrRtxMemoryInit(mem, size, 1U);return 1U;
}/// Allocate a memory block from a Memory Pool.
/// \param[in]  mem             pointer to memory pool.
/// \param[in]  size            size of a memory block in bytes.
/// \param[in]  type            memory block type: 0 - generic, 1 - control block
/// \return allocated memory block or NULL in case of no memory is available.
__WEAK void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type) {mem_block_t *ptr;mem_block_t *p, *p_new;uint32_t     block_size;uint32_t     hole_size;// Check parametersif ((mem == NULL) || (size == 0U) || ((type & ~MB_INFO_TYPE_MASK) != 0U)) {//EvrRtxMemoryAlloc(mem, size, type, NULL);//lint -e{904} "Return statement before end of function" [MISRA Note 1]return NULL;}// Add block header to sizeblock_size = size + sizeof(mem_block_t);// Make sure that block is 8-byte alignedblock_size = (block_size + 7U) & ~((uint32_t)7U);// Search for hole big enoughp = MemBlockPtr(mem, sizeof(mem_head_t));for (;;) {//lint -e{923} -e{9078} "cast from pointer to unsigned int"hole_size  = (uint32_t)p->next - (uint32_t)p;hole_size -= p->info & MB_INFO_LEN_MASK;if (hole_size >= block_size) {// Hole foundbreak;}p = p->next;if (p->next == NULL) {// Failed (end of list)//EvrRtxMemoryAlloc(mem, size, type, NULL);//lint -e{904} "Return statement before end of function" [MISRA Note 1]return NULL;}}// Update used memory(MemHeadPtr(mem))->used += block_size;// Update max used memoryp_new = MemBlockPtr(mem, (MemHeadPtr(mem))->size - sizeof(mem_block_t));if (p_new->info < (MemHeadPtr(mem))->used) {p_new->info = (MemHeadPtr(mem))->used;}// Allocate blockif (p->info == 0U) {// No block allocated, set info of first elementp->info = block_size | type;ptr = MemBlockPtr(p, sizeof(mem_block_t));} else {// Insert new element into the listp_new = MemBlockPtr(p, p->info & MB_INFO_LEN_MASK);p_new->next = p->next;p_new->info = block_size | type;p->next = p_new;ptr = MemBlockPtr(p_new, sizeof(mem_block_t));}//EvrRtxMemoryAlloc(mem, size, type, ptr);return ptr;
}/// Return an allocated memory block back to a Memory Pool.
/// \param[in]  mem             pointer to memory pool.
/// \param[in]  block           memory block to be returned to the memory pool.
/// \return 1 - success, 0 - failure.
__WEAK uint32_t osRtxMemoryFree (void *mem, void *block) {const mem_block_t *ptr;mem_block_t *p, *p_prev;// Check parametersif ((mem == NULL) || (block == NULL)) {//EvrRtxMemoryFree(mem, block, 0U);//lint -e{904} "Return statement before end of function" [MISRA Note 1]return 0U;}// Memory block headerptr = MemBlockPtr(block, 0U);ptr--;// Search for block headerp_prev = NULL;p = MemBlockPtr(mem, sizeof(mem_head_t));while (p != ptr) {p_prev = p;p = p->next;if (p == NULL) {// Not found//EvrRtxMemoryFree(mem, block, 0U);//lint -e{904} "Return statement before end of function" [MISRA Note 1]return 0U;}}// Update used memory(MemHeadPtr(mem))->used -= p->info & MB_INFO_LEN_MASK;// Free blockif (p_prev == NULL) {// Release first block, only set info to 0p->info = 0U;} else {// Discard block from chained listp_prev->next = p->next;}//EvrRtxMemoryFree(mem, block, 1U);return 1U;
}

main.c

/* D1, AXI SRAM, 512KB */
mem_head_t *AXISRAMUsed;
uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));/* D2, 128KB SRAM1(0x30000000) + 128KB SRAM2(0x30020000) + 32KB SRAM3(0x30040000)  */
mem_head_t *SRAM1Used; 
uint64_t AppMallocSRAM1[288*1024/8]__attribute__((at(0x30000000)));/* D3, SRAM4, 64KB */
mem_head_t *SRAM4Used;
uint64_t AppMallocSRAM4[64*1024/8]__attribute__((at(0x38000000)));
uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;bsp_Init();osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));/* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
printf("=========================================================\r\n");
DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("DTCM 总大小 = %d 字节，申请大小 = 0280 字节，当前共使用大小 = %d 字节\r\n", DTCMUsed->size, DTCMUsed->used);
/* 从 DTCM 申请 64 字节空间，使用指针变量 DTCM_Addres1 操作这些空间时不要超过 64 字节大小 */
DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("DTCM 总大小 = %d 字节，申请大小 = 0064 字节，当前共使用大小 = %d 字节\r\n", DTCMUsed->size, DTCMUsed->used);/* 从 DTCM 申请 6111 字节空间，使用指针变量 DTCM_Addres2 操作这些空间时不要超过 6111 字节大小 */
DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("DTCM 总大小 = %d 字节，申请大小 = 6111 字节，当前共使用大小 = %d 字节\r\n", DTCMUsed->size, DTCMUsed->used);
break;