UCOS_TI_LM3S_Keil
 全部 结构体 文件 函数 变量 类型定义 宏定义 页
结构体 | 宏定义 | 类型定义 | 函数
lib_mem.h 文件参考
#include <cpu.h>
#include <cpu_core.h>
#include <lib_def.h>
#include <app_cfg.h>
lib_mem.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

结构体

struct  MEM_POOL
 

宏定义

#define LIB_MEM_EXT   extern
 
#define LIB_MEM_ERR_NONE   10000
 
#define LIB_MEM_ERR_NULL_PTR   10001 /* Ptr arg(s) passed NULL ptr(s). */
 
#define LIB_MEM_ERR_INVALID_MEM_SIZE   10100 /* Invalid mem size. */
 
#define LIB_MEM_ERR_INVALID_SEG_SIZE   10110 /* Invalid mem seg size. */
 
#define LIB_MEM_ERR_INVALID_SEG_OVERLAP   10111 /* Invalid mem seg overlaps other mem seg(s). */
 
#define LIB_MEM_ERR_INVALID_POOL   10120 /* Invalid mem pool. */
 
#define LIB_MEM_ERR_INVALID_BLK_NBR   10130 /* Invalid mem pool blk nbr. */
 
#define LIB_MEM_ERR_INVALID_BLK_SIZE   10131 /* Invalid mem pool blk size. */
 
#define LIB_MEM_ERR_INVALID_BLK_IX   10132 /* Invalid mem pool ix. */
 
#define LIB_MEM_ERR_INVALID_BLK_ADDR   10135 /* Invalid mem pool blk addr. */
 
#define LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL   10136 /* Mem pool blk addr already in mem pool. */
 
#define LIB_MEM_ERR_SEG_EMPTY   10200 /* Mem seg empty; i.e. NO avail mem for mem pools. */
 
#define LIB_MEM_ERR_POOL_FULL   10205 /* Mem pool full; i.e. All mem blks avail in mem pool. */
 
#define LIB_MEM_ERR_POOL_EMPTY   10206 /* Mem pool empty; i.e. NO mem blks avail in mem pool. */
 
#define LIB_MEM_ERR_HEAP_NOT_FOUND   10210 /* Heap seg NOT found. */
 
#define LIB_MEM_ERR_HEAP_EMPTY   10211 /* Heap seg empty; i.e. NO avail mem in heap. */
 
#define LIB_MEM_TYPE_NONE   0x454E4F4E /* "NONE" in ASCII. */
 
#define LIB_MEM_TYPE_HEAP   0x50414548 /* "HEAP" in ASCII. */
 
#define LIB_MEM_TYPE_POOL   0x4C4F4F50 /* "POOL" in ASCII. */
 
#define MEM_POOL_IX_NONE   DEF_INT_16U_MAX_VAL /* Define as max unsigned val (see Note #1). */
 
#define MEM_POOL_IX_MIN   1
 
#define MEM_POOL_IX_MAX   (MEM_POOL_IX_NONE - 1)
 
#define MEM_VAL_GET_INT08U_BIG(addr)   ((CPU_INT08U) (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)))
 
#define MEM_VAL_GET_INT16U_BIG(addr)
 
#define MEM_VAL_GET_INT32U_BIG(addr)
 
#define MEM_VAL_GET_INT08U_LITTLE(addr)   ((CPU_INT08U) (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)))
 
#define MEM_VAL_GET_INT16U_LITTLE(addr)
 
#define MEM_VAL_GET_INT32U_LITTLE(addr)
 
#define MEM_VAL_GET_INT08U(addr)   MEM_VAL_GET_INT08U_LITTLE(addr)
 
#define MEM_VAL_GET_INT16U(addr)   MEM_VAL_GET_INT16U_LITTLE(addr)
 
#define MEM_VAL_GET_INT32U(addr)   MEM_VAL_GET_INT32U_LITTLE(addr)
 
#define MEM_VAL_SET_INT08U_BIG(addr, val)   { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & 0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }
 
#define MEM_VAL_SET_INT16U_BIG(addr, val)
 
#define MEM_VAL_SET_INT32U_BIG(addr, val)
 
#define MEM_VAL_SET_INT08U_LITTLE(addr, val)   { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & 0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }
 
#define MEM_VAL_SET_INT16U_LITTLE(addr, val)
 
#define MEM_VAL_SET_INT32U_LITTLE(addr, val)
 
#define MEM_VAL_SET_INT08U(addr, val)   MEM_VAL_SET_INT08U_LITTLE(addr, val)
 
#define MEM_VAL_SET_INT16U(addr, val)   MEM_VAL_SET_INT16U_LITTLE(addr, val)
 
#define MEM_VAL_SET_INT32U(addr, val)   MEM_VAL_SET_INT32U_LITTLE(addr, val)
 
#define MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)   { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
 
#define MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)   { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
 
#define MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT08U_BIG(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT16U_BIG(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT32U_BIG(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT08U_LITTLE(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT16U_LITTLE(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT32U_LITTLE(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT08U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT16U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)
 
#define MEM_VAL_COPY_SET_INT32U(addr_dest, addr_src)   MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)
 
#define MEM_VAL_COPY_08(addr_dest, addr_src)   { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
 
#define MEM_VAL_COPY_16(addr_dest, addr_src)
 
#define MEM_VAL_COPY_32(addr_dest, addr_src)
 

类型定义

typedef CPU_INT32U LIB_MEM_TYPE
 
typedef CPU_INT16U MEM_POOL_IX
 

函数

void Mem_Init (void)
 
void Mem_Clr (void *pmem, CPU_SIZE_T size)
 
void Mem_Set (void *pmem, CPU_INT08U data_val, CPU_SIZE_T size)
 
void Mem_Copy (void *pdest, void *psrc, CPU_SIZE_T size)
 
CPU_BOOLEAN Mem_Cmp (void *p1_mem, void *p2_mem, CPU_SIZE_T size)
 
void * Mem_HeapAlloc (CPU_SIZE_T size, CPU_SIZE_T align, CPU_SIZE_T *poctets_reqd, LIB_ERR *perr)
 
void Mem_PoolClr (MEM_POOL *pmem_pool, LIB_ERR *perr)
 
void Mem_PoolCreate (MEM_POOL *pmem_pool, void *pmem_base_addr, CPU_SIZE_T mem_size, CPU_SIZE_T blk_nbr, CPU_SIZE_T blk_size, CPU_SIZE_T blk_align, CPU_SIZE_T *poctets_reqd, LIB_ERR *perr)
 
void * Mem_PoolBlkGet (MEM_POOL *pmem_pool, CPU_SIZE_T size, LIB_ERR *perr)
 
void Mem_PoolBlkFree (MEM_POOL *pmem_pool, void *pmem_blk, LIB_ERR *perr)
 

结构体说明

struct mem_pool

在文件 lib_mem.h 第 320 行定义.

MEM_POOL 的协作图:
Collaboration graph
成员变量
LIB_MEM_TYPE Type
MEM_POOL * SegPrevPtr
MEM_POOL * SegNextPtr
MEM_POOL * PoolPrevPtr
MEM_POOL * PoolNextPtr
void * PoolAddrStart
void * PoolAddrEnd
void ** PoolPtrs
MEM_POOL_IX BlkIx
CPU_SIZE_T PoolSize
CPU_SIZE_T BlkNbr
CPU_SIZE_T BlkSize
CPU_SIZE_T BlkAlign
void * SegAddr
void * SegAddrNextAvail
CPU_SIZE_T SegSizeTot
CPU_SIZE_T SegSizeRem

宏定义说明

#define LIB_MEM_EXT   extern

在文件 lib_mem.h 第 104 行定义.

#define LIB_MEM_ERR_NONE   10000

在文件 lib_mem.h 第 180 行定义.

参考自 Mem_HeapAlloc(), Mem_PoolBlkFree(), Mem_PoolBlkGet(), Mem_PoolClr() , 以及 Mem_PoolCreate().

#define LIB_MEM_ERR_NULL_PTR   10001 /* Ptr arg(s) passed NULL ptr(s). */

在文件 lib_mem.h 第 181 行定义.

参考自 Mem_PoolBlkFree(), Mem_PoolBlkGet() , 以及 Mem_PoolClr().

#define LIB_MEM_ERR_INVALID_MEM_SIZE   10100 /* Invalid mem size. */

在文件 lib_mem.h 第 183 行定义.

参考自 Mem_HeapAlloc().

#define LIB_MEM_ERR_INVALID_SEG_SIZE   10110 /* Invalid mem seg size. */

在文件 lib_mem.h 第 184 行定义.

参考自 Mem_PoolCreate().

#define LIB_MEM_ERR_INVALID_SEG_OVERLAP   10111 /* Invalid mem seg overlaps other mem seg(s). */

在文件 lib_mem.h 第 185 行定义.

参考自 Mem_PoolCreate().

#define LIB_MEM_ERR_INVALID_POOL   10120 /* Invalid mem pool. */

在文件 lib_mem.h 第 186 行定义.

参考自 Mem_PoolBlkFree() , 以及 Mem_PoolBlkGet().

#define LIB_MEM_ERR_INVALID_BLK_NBR   10130 /* Invalid mem pool blk nbr. */

在文件 lib_mem.h 第 187 行定义.

参考自 Mem_PoolCreate().

#define LIB_MEM_ERR_INVALID_BLK_SIZE   10131 /* Invalid mem pool blk size. */

在文件 lib_mem.h 第 188 行定义.

参考自 Mem_PoolBlkGet() , 以及 Mem_PoolCreate().

#define LIB_MEM_ERR_INVALID_BLK_IX   10132 /* Invalid mem pool ix. */

在文件 lib_mem.h 第 189 行定义.

参考自 Mem_PoolBlkGet().

#define LIB_MEM_ERR_INVALID_BLK_ADDR   10135 /* Invalid mem pool blk addr. */

在文件 lib_mem.h 第 190 行定义.

参考自 Mem_PoolBlkFree().

#define LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL   10136 /* Mem pool blk addr already in mem pool. */

在文件 lib_mem.h 第 191 行定义.

参考自 Mem_PoolBlkFree().

#define LIB_MEM_ERR_SEG_EMPTY   10200 /* Mem seg empty; i.e. NO avail mem for mem pools. */

在文件 lib_mem.h 第 193 行定义.

参考自 Mem_PoolCreate().

#define LIB_MEM_ERR_POOL_FULL   10205 /* Mem pool full; i.e. All mem blks avail in mem pool. */

在文件 lib_mem.h 第 194 行定义.

参考自 Mem_PoolBlkFree().

#define LIB_MEM_ERR_POOL_EMPTY   10206 /* Mem pool empty; i.e. NO mem blks avail in mem pool. */

在文件 lib_mem.h 第 195 行定义.

参考自 Mem_PoolBlkGet().

#define LIB_MEM_ERR_HEAP_NOT_FOUND   10210 /* Heap seg NOT found. */

在文件 lib_mem.h 第 197 行定义.

参考自 Mem_PoolCreate().

#define LIB_MEM_ERR_HEAP_EMPTY   10211 /* Heap seg empty; i.e. NO avail mem in heap. */

在文件 lib_mem.h 第 198 行定义.

参考自 Mem_HeapAlloc() , 以及 Mem_PoolCreate().

#define LIB_MEM_TYPE_NONE   0x454E4F4E /* "NONE" in ASCII. */

在文件 lib_mem.h 第 220 行定义.

参考自 Mem_PoolClr().

#define LIB_MEM_TYPE_HEAP   0x50414548 /* "HEAP" in ASCII. */

在文件 lib_mem.h 第 221 行定义.

参考自 Mem_Init().

#define LIB_MEM_TYPE_POOL   0x4C4F4F50 /* "POOL" in ASCII. */

在文件 lib_mem.h 第 222 行定义.

参考自 Mem_PoolBlkFree(), Mem_PoolBlkGet() , 以及 Mem_PoolCreate().

#define MEM_POOL_IX_NONE   DEF_INT_16U_MAX_VAL /* Define as max unsigned val (see Note #1). */

在文件 lib_mem.h 第 267 行定义.

#define MEM_POOL_IX_MIN   1

在文件 lib_mem.h 第 268 行定义.

#define MEM_POOL_IX_MAX   (MEM_POOL_IX_NONE - 1)

在文件 lib_mem.h 第 269 行定义.

#define MEM_VAL_GET_INT08U_BIG (   addr)    ((CPU_INT08U) (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)))

在文件 lib_mem.h 第 436 行定义.

#define MEM_VAL_GET_INT16U_BIG (   addr)
值:
((CPU_INT16U)((((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (1 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (0 * DEF_OCTET_NBR_BITS))))

在文件 lib_mem.h 第 438 行定义.

#define MEM_VAL_GET_INT32U_BIG (   addr)
值:
((CPU_INT32U)((((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (3 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (2 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (1 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (0 * DEF_OCTET_NBR_BITS))))

在文件 lib_mem.h 第 441 行定义.

#define MEM_VAL_GET_INT08U_LITTLE (   addr)    ((CPU_INT08U) (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)))

在文件 lib_mem.h 第 448 行定义.

#define MEM_VAL_GET_INT16U_LITTLE (   addr)
值:
((CPU_INT16U)((((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (1 * DEF_OCTET_NBR_BITS))))

在文件 lib_mem.h 第 450 行定义.

#define MEM_VAL_GET_INT32U_LITTLE (   addr)
值:
((CPU_INT32U)((((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (1 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (2 * DEF_OCTET_NBR_BITS)) + \
(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (3 * DEF_OCTET_NBR_BITS))))

在文件 lib_mem.h 第 453 行定义.

#define MEM_VAL_GET_INT08U (   addr)    MEM_VAL_GET_INT08U_LITTLE(addr)

在文件 lib_mem.h 第 468 行定义.

#define MEM_VAL_GET_INT16U (   addr)    MEM_VAL_GET_INT16U_LITTLE(addr)

在文件 lib_mem.h 第 469 行定义.

#define MEM_VAL_GET_INT32U (   addr)    MEM_VAL_GET_INT32U_LITTLE(addr)

在文件 lib_mem.h 第 470 行定义.

#define MEM_VAL_SET_INT08U_BIG (   addr,
  val 
)    { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & 0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 532 行定义.

#define MEM_VAL_SET_INT16U_BIG (   addr,
  val 
)
值:
{ (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & 0xFF00) >> (1 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & 0x00FF) >> (0 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 534 行定义.

#define MEM_VAL_SET_INT32U_BIG (   addr,
  val 
)
值:
{ (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0xFF000000) >> (3 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x00FF0000) >> (2 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x0000FF00) >> (1 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x000000FF) >> (0 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 537 行定义.

#define MEM_VAL_SET_INT08U_LITTLE (   addr,
  val 
)    { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & 0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 544 行定义.

#define MEM_VAL_SET_INT16U_LITTLE (   addr,
  val 
)
值:
{ (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & 0x00FF) >> (0 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & 0xFF00) >> (1 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 546 行定义.

#define MEM_VAL_SET_INT32U_LITTLE (   addr,
  val 
)
值:
{ (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x000000FF) >> (0 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x0000FF00) >> (1 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x00FF0000) >> (2 * DEF_OCTET_NBR_BITS))); \
(*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0xFF000000) >> (3 * DEF_OCTET_NBR_BITS))); }

在文件 lib_mem.h 第 549 行定义.

#define MEM_VAL_SET_INT08U (   addr,
  val 
)    MEM_VAL_SET_INT08U_LITTLE(addr, val)

在文件 lib_mem.h 第 564 行定义.

#define MEM_VAL_SET_INT16U (   addr,
  val 
)    MEM_VAL_SET_INT16U_LITTLE(addr, val)

在文件 lib_mem.h 第 565 行定义.

#define MEM_VAL_SET_INT32U (   addr,
  val 
)    MEM_VAL_SET_INT32U_LITTLE(addr, val)

在文件 lib_mem.h 第 566 行定义.

#define MEM_VAL_COPY_GET_INT08U_BIG (   addr_dest,
  addr_src 
)    { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }

在文件 lib_mem.h 第 670 行定义.

#define MEM_VAL_COPY_GET_INT16U_BIG (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }

在文件 lib_mem.h 第 672 行定义.

#define MEM_VAL_COPY_GET_INT32U_BIG (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
(*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
(*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }

在文件 lib_mem.h 第 675 行定义.

#define MEM_VAL_COPY_GET_INT08U_LITTLE (   addr_dest,
  addr_src 
)    { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }

在文件 lib_mem.h 第 682 行定义.

#define MEM_VAL_COPY_GET_INT16U_LITTLE (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); }

在文件 lib_mem.h 第 684 行定义.

#define MEM_VAL_COPY_GET_INT32U_LITTLE (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
(*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
(*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); }

在文件 lib_mem.h 第 687 行定义.

#define MEM_VAL_COPY_GET_INT08U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 694 行定义.

#define MEM_VAL_COPY_GET_INT16U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 695 行定义.

#define MEM_VAL_COPY_GET_INT32U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 696 行定义.

#define MEM_VAL_COPY_SET_INT08U_BIG (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)

在文件 lib_mem.h 第 760 行定义.

#define MEM_VAL_COPY_SET_INT16U_BIG (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)

在文件 lib_mem.h 第 761 行定义.

#define MEM_VAL_COPY_SET_INT32U_BIG (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)

在文件 lib_mem.h 第 762 行定义.

#define MEM_VAL_COPY_SET_INT08U_LITTLE (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 764 行定义.

#define MEM_VAL_COPY_SET_INT16U_LITTLE (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 765 行定义.

#define MEM_VAL_COPY_SET_INT32U_LITTLE (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)

在文件 lib_mem.h 第 766 行定义.

#define MEM_VAL_COPY_SET_INT08U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)

在文件 lib_mem.h 第 769 行定义.

#define MEM_VAL_COPY_SET_INT16U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)

在文件 lib_mem.h 第 770 行定义.

#define MEM_VAL_COPY_SET_INT32U (   addr_dest,
  addr_src 
)    MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)

在文件 lib_mem.h 第 771 行定义.

#define MEM_VAL_COPY_08 (   addr_dest,
  addr_src 
)    { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }

在文件 lib_mem.h 第 806 行定义.

#define MEM_VAL_COPY_16 (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); }

在文件 lib_mem.h 第 808 行定义.

#define MEM_VAL_COPY_32 (   addr_dest,
  addr_src 
)
值:
{ (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
(*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
(*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
(*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); }

在文件 lib_mem.h 第 811 行定义.

类型定义说明

typedef CPU_INT32U LIB_MEM_TYPE

在文件 lib_mem.h 第 254 行定义.

typedef CPU_INT16U MEM_POOL_IX

在文件 lib_mem.h 第 265 行定义.

函数说明

void Mem_Init ( void  )

在文件 lib_mem.c 第 161 行定义.

参考 LIB_MEM_CFG_HEAP_SIZE, LIB_MEM_TYPE_HEAP, Mem_Heap, Mem_PoolHeap , 以及 Mem_PoolTbl.

参考自 App_TaskStart().

162 {
163 #if (LIB_MEM_CFG_ALLOC_EN == DEF_ENABLED)
164  MEM_POOL *pmem_pool;
165 
166  /* --------- INIT MEM HEAP SEG / POOL --------- */
167  pmem_pool = (MEM_POOL *)&Mem_PoolHeap;
168  pmem_pool->Type = (LIB_MEM_TYPE) LIB_MEM_TYPE_HEAP;
169  pmem_pool->SegPrevPtr = (MEM_POOL *) 0;
170  pmem_pool->SegNextPtr = (MEM_POOL *) 0;
171  pmem_pool->PoolPrevPtr = (MEM_POOL *) 0;
172  pmem_pool->PoolNextPtr = (MEM_POOL *) 0;
173  pmem_pool->PoolAddrStart = (void *) 0;
174  pmem_pool->PoolAddrEnd = (void *) 0;
175  pmem_pool->PoolPtrs = (void **) 0;
176  pmem_pool->BlkSize = (CPU_SIZE_T ) 0;
177  pmem_pool->BlkNbr = (CPU_SIZE_T ) 0;
178  pmem_pool->BlkIx = (MEM_POOL_IX ) 0;
179 
180 #ifdef LIB_MEM_CFG_HEAP_BASE_ADDR
181  pmem_pool->SegAddr = (void *) LIB_MEM_CFG_HEAP_BASE_ADDR;
182  pmem_pool->SegAddrNextAvail = (void *) LIB_MEM_CFG_HEAP_BASE_ADDR;
183 #else
184  pmem_pool->SegAddr = (void *)&Mem_Heap[0];
185  pmem_pool->SegAddrNextAvail = (void *)&Mem_Heap[0];
186 #endif
187 
188  pmem_pool->SegSizeTot = (CPU_SIZE_T ) LIB_MEM_CFG_HEAP_SIZE;
189  pmem_pool->SegSizeRem = (CPU_SIZE_T ) LIB_MEM_CFG_HEAP_SIZE;
190 
191  /* ------------ INIT MEM POOL TBL ------------- */
192  Mem_PoolTbl = &Mem_PoolHeap;
193 #endif
194 }

这是这个函数的调用关系图:

void Mem_Clr ( void *  pmem,
CPU_SIZE_T  size 
)

在文件 lib_mem.c 第 220 行定义.

参考 Mem_Set().

222 {
223  Mem_Set((void *)pmem,
224  (CPU_INT08U)0, /* See Note #2. */
225  (CPU_SIZE_T)size);
226 }

函数调用图:

void Mem_Set ( void *  pmem,
CPU_INT08U  data_val,
CPU_SIZE_T  size 
)

在文件 lib_mem.c 第 264 行定义.

参考 DEF_OCTET_NBR_BITS.

参考自 Mem_Clr().

267 {
268  CPU_SIZE_T size_rem;
269  CPU_ALIGN data_align;
270  CPU_ALIGN *pmem_align;
271  CPU_INT08U *pmem_08;
272  CPU_INT08U mem_align_modulo;
273  CPU_INT08U i;
274 
275 
276  if (size < 1) { /* See Note #1. */
277  return;
278  }
279  if (pmem == (void *)0) {
280  return;
281  }
282 
283 
284  data_align = 0;
285  for (i = 0; i < sizeof(CPU_ALIGN); i++) { /* Fill each data_align octet with data val. */
286  data_align <<= DEF_OCTET_NBR_BITS;
287  data_align |= (CPU_ALIGN)data_val;
288  }
289 
290  size_rem = (CPU_SIZE_T)size;
291  mem_align_modulo = (CPU_INT08U)((CPU_ADDR)pmem % sizeof(CPU_ALIGN)); /* See Note #3. */
292 
293  pmem_08 = (CPU_INT08U *)pmem;
294  if (mem_align_modulo != 0) { /* If leading octets avail, ... */
295  i = mem_align_modulo;
296  while ((size_rem > 0) && /* ... start mem buf fill with leading octets ... */
297  (i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
298  *pmem_08++ = data_val;
299  size_rem -= sizeof(CPU_INT08U);
300  i++;
301  }
302  }
303 
304  pmem_align = (CPU_ALIGN *)pmem_08; /* See Note #2a. */
305  while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem buf aligned on CPU_ALIGN word boundaries, */
306  *pmem_align++ = data_align; /* ... fill mem buf with CPU_ALIGN-sized data. */
307  size_rem -= sizeof(CPU_ALIGN);
308  }
309 
310  pmem_08 = (CPU_INT08U *)pmem_align;
311  while (size_rem > 0) { /* Finish mem buf fill with trailing octets. */
312  *pmem_08++ = data_val;
313  size_rem -= sizeof(CPU_INT08U);
314  }
315 }

这是这个函数的调用关系图:

void Mem_Copy ( void *  pdest,
void *  psrc,
CPU_SIZE_T  size 
)
CPU_BOOLEAN Mem_Cmp ( void *  p1_mem,
void *  p2_mem,
CPU_SIZE_T  size 
)

在文件 lib_mem.c 第 466 行定义.

参考 DEF_NO , 以及 DEF_YES.

469 {
470  CPU_SIZE_T size_rem;
471  CPU_ALIGN *p1_mem_align;
472  CPU_ALIGN *p2_mem_align;
473  CPU_INT08U *p1_mem_08;
474  CPU_INT08U *p2_mem_08;
475  CPU_INT08U i;
476  CPU_INT08U mem_align_modulo_1;
477  CPU_INT08U mem_align_modulo_2;
478  CPU_BOOLEAN mem_aligned;
479  CPU_BOOLEAN mem_cmp;
480 
481 
482  if (size < 1) { /* See Note #1. */
483  return (DEF_YES);
484  }
485  if (p1_mem == (void *)0) {
486  return (DEF_NO);
487  }
488  if (p2_mem == (void *)0) {
489  return (DEF_NO);
490  }
491 
492 
493  mem_cmp = DEF_YES; /* Assume mem bufs are identical until cmp fails. */
494  size_rem = size;
495  /* Start @ end of mem bufs (see Note #2). */
496  p1_mem_08 = (CPU_INT08U *)p1_mem + size;
497  p2_mem_08 = (CPU_INT08U *)p2_mem + size;
498  /* See Note #4. */
499  mem_align_modulo_1 = (CPU_INT08U )((CPU_ADDR)p1_mem_08 % sizeof(CPU_ALIGN));
500  mem_align_modulo_2 = (CPU_INT08U )((CPU_ADDR)p2_mem_08 % sizeof(CPU_ALIGN));
501 
502  mem_aligned = (mem_align_modulo_1 == mem_align_modulo_2) ? DEF_YES : DEF_NO;
503 
504  if (mem_aligned == DEF_YES) { /* If mem bufs' alignment offset equal, ... */
505  /* ... optimize cmp for mem buf alignment. */
506  if (mem_align_modulo_1 != 0) { /* If trailing octets avail, ... */
507  i = mem_align_modulo_1;
508  while ((mem_cmp == DEF_YES) && /* ... cmp mem bufs while identical & ... */
509  (size_rem > 0) && /* ... start mem buf cmp with trailing octets ... */
510  (i > 0)) { /* ... until next CPU_ALIGN word boundary. */
511  p1_mem_08--;
512  p2_mem_08--;
513  if (*p1_mem_08 != *p2_mem_08) { /* If ANY data octet(s) NOT identical, cmp fails. */
514  mem_cmp = DEF_NO;
515  }
516  size_rem -= sizeof(CPU_INT08U);
517  i--;
518  }
519  }
520 
521  if (mem_cmp == DEF_YES) { /* If cmp still identical, cmp aligned mem bufs. */
522  p1_mem_align = (CPU_ALIGN *)p1_mem_08; /* See Note #3a. */
523  p2_mem_align = (CPU_ALIGN *)p2_mem_08;
524 
525  while ((mem_cmp == DEF_YES) && /* Cmp mem bufs while identical & ... */
526  (size_rem >= sizeof(CPU_ALIGN))) { /* ... mem bufs aligned on CPU_ALIGN word boundaries. */
527  p1_mem_align--;
528  p2_mem_align--;
529  if (*p1_mem_align != *p2_mem_align) { /* If ANY data octet(s) NOT identical, cmp fails. */
530  mem_cmp = DEF_NO;
531  }
532  size_rem -= sizeof(CPU_ALIGN);
533  }
534 
535  p1_mem_08 = (CPU_INT08U *)p1_mem_align;
536  p2_mem_08 = (CPU_INT08U *)p2_mem_align;
537  }
538  }
539 
540  while ((mem_cmp == DEF_YES) && /* Cmp mem bufs while identical ... */
541  (size_rem > 0)) { /* ... for unaligned mem bufs or trailing octets. */
542  p1_mem_08--;
543  p2_mem_08--;
544  if (*p1_mem_08 != *p2_mem_08) { /* If ANY data octet(s) NOT identical, cmp fails. */
545  mem_cmp = DEF_NO;
546  }
547  size_rem -= sizeof(CPU_INT08U);
548  }
549 
550  return (mem_cmp);
551 }
void* Mem_HeapAlloc ( CPU_SIZE_T  size,
CPU_SIZE_T  align,
CPU_SIZE_T *  poctets_reqd,
LIB_ERR *  perr 
)

在文件 lib_mem.c 第 592 行定义.

参考 CPU_CRITICAL_ENTER, CPU_CRITICAL_EXIT, CPU_SR_ALLOC, LIB_MEM_ERR_HEAP_EMPTY, LIB_MEM_ERR_INVALID_MEM_SIZE, LIB_MEM_ERR_NONE, Mem_PoolHeap, Mem_PoolSegAlloc() , 以及 Mem_PoolSegCalcTotSize().

596 {
597  MEM_POOL *pmem_pool_heap;
598  void *pmem_addr;
599  void *pmem_blk;
600  CPU_SIZE_T size_rem;
601  CPU_SIZE_T size_req;
602  CPU_SR_ALLOC();
603 
604  /* Init octets req'd for err (see Note #1). */
605  if (poctets_reqd != (CPU_SIZE_T *)0) {
606  *poctets_reqd = (CPU_SIZE_T )0;
607  }
608 
609  /* ------------ VALIDATE HEAP MEM ALLOC ----------- */
610 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
611  if (size < 1) {
612  *perr = LIB_MEM_ERR_INVALID_MEM_SIZE;
613  return ((void *)0);
614  }
615 #endif
616  if (align < 1) {
617  align = 1;
618  }
619 
620  /* -------------- ALLOC HEAP MEM BLK -------------- */
621  pmem_pool_heap = &Mem_PoolHeap;
622 
623  CPU_CRITICAL_ENTER();
624 
625  pmem_addr = pmem_pool_heap->SegAddrNextAvail;
626  size_rem = pmem_pool_heap->SegSizeRem;
627  size_req = Mem_PoolSegCalcTotSize((void *)pmem_addr,
628  (CPU_SIZE_T)1, /* Alloc for single mem blk from heap. */
629  (CPU_SIZE_T)size,
630  (CPU_SIZE_T)align);
631  if (size_req > size_rem) { /* If req'd size > rem heap size, ... */
632  CPU_CRITICAL_EXIT();
633  *perr = LIB_MEM_ERR_HEAP_EMPTY;
634  if (poctets_reqd != (CPU_SIZE_T *)0) {
635  *poctets_reqd = size_req - size_rem; /* ... rtn add'l heap size needed. */
636  }
637  return ((void *)0);
638  }
639 
640  pmem_blk = Mem_PoolSegAlloc(pmem_pool_heap, size, align);
641  if (pmem_blk == (void *)0) { /* If mem blk NOT avail from heap, ... */
642  CPU_CRITICAL_EXIT();
643  *perr = LIB_MEM_ERR_HEAP_EMPTY;
644  if (poctets_reqd != (CPU_SIZE_T *)0) {
645  *poctets_reqd = size_req; /* ... rtn add'l heap size needed. */
646  }
647  return ((void *)0);
648  }
649 
650  CPU_CRITICAL_EXIT();
651 
652  *perr = LIB_MEM_ERR_NONE;
653 
654  return (pmem_blk);
655 }

函数调用图:

void Mem_PoolClr ( MEM_POOL *  pmem_pool,
LIB_ERR *  perr 
)

在文件 lib_mem.c 第 683 行定义.

参考 LIB_MEM_ERR_NONE, LIB_MEM_ERR_NULL_PTR , 以及 LIB_MEM_TYPE_NONE.

参考自 Mem_PoolCreate().

685 {
686 
687  /* ------------------- VALIDATE PTR ------------------- */
688  if (pmem_pool == (MEM_POOL *)0) {
689  *perr = LIB_MEM_ERR_NULL_PTR;
690  return;
691  }
692 
693 
694  pmem_pool->Type = (LIB_MEM_TYPE)LIB_MEM_TYPE_NONE;
695  pmem_pool->SegPrevPtr = (MEM_POOL *)0;
696  pmem_pool->SegNextPtr = (MEM_POOL *)0;
697  pmem_pool->PoolPrevPtr = (MEM_POOL *)0;
698  pmem_pool->PoolNextPtr = (MEM_POOL *)0;
699  pmem_pool->PoolAddrStart = (void *)0;
700  pmem_pool->PoolAddrEnd = (void *)0;
701  pmem_pool->PoolPtrs = (void **)0;
702  pmem_pool->PoolSize = (CPU_SIZE_T )0;
703  pmem_pool->BlkAlign = (CPU_SIZE_T )0;
704  pmem_pool->BlkSize = (CPU_SIZE_T )0;
705  pmem_pool->BlkNbr = (CPU_SIZE_T )0;
706  pmem_pool->BlkIx = (MEM_POOL_IX )0;
707  pmem_pool->SegAddr = (void *)0;
708  pmem_pool->SegAddrNextAvail = (void *)0;
709  pmem_pool->SegSizeTot = (CPU_SIZE_T )0;
710  pmem_pool->SegSizeRem = (CPU_SIZE_T )0;
711 
712 
713  *perr = LIB_MEM_ERR_NONE;
714 }

这是这个函数的调用关系图:

void Mem_PoolCreate ( MEM_POOL *  pmem_pool,
void *  pmem_base_addr,
CPU_SIZE_T  mem_size,
CPU_SIZE_T  blk_nbr,
CPU_SIZE_T  blk_size,
CPU_SIZE_T  blk_align,
CPU_SIZE_T *  poctets_reqd,
LIB_ERR *  perr 
)

在文件 lib_mem.c 第 868 行定义.

参考 CPU_CRITICAL_ENTER, CPU_CRITICAL_EXIT, CPU_SR_ALLOC, LIB_MEM_ERR_HEAP_EMPTY, LIB_MEM_ERR_HEAP_NOT_FOUND, LIB_MEM_ERR_INVALID_BLK_NBR, LIB_MEM_ERR_INVALID_BLK_SIZE, LIB_MEM_ERR_INVALID_SEG_OVERLAP, LIB_MEM_ERR_INVALID_SEG_SIZE, LIB_MEM_ERR_NONE, LIB_MEM_ERR_SEG_EMPTY, LIB_MEM_TYPE_POOL, Mem_PoolClr(), Mem_PoolHeap, Mem_PoolSegAlloc(), Mem_PoolSegCalcTotSize() , 以及 Mem_PoolTbl.

876 {
877  MEM_POOL *pmem_pool_heap;
878  MEM_POOL *pmem_pool_prev;
879  MEM_POOL *pmem_pool_next;
880  MEM_POOL *pmem_pool_blk;
881  void **ppool_ptr;
882  void *pmem_blk;
883  CPU_INT08U *pmem_addr_ptrs;
884  CPU_INT08U *pmem_addr_pool;
885  CPU_INT08U *pmem_base_addr_start;
886  CPU_INT08U *pmem_base_addr_end;
887  CPU_INT08U *pmem_seg_addr_start;
888  CPU_INT08U *pmem_seg_addr_end;
889  CPU_SIZE_T size_tot;
890  CPU_SIZE_T size_tot_ptrs;
891  CPU_SIZE_T size_tot_pool;
892  CPU_SIZE_T size_rem;
893  CPU_SIZE_T size_pool_ptrs;
894  CPU_SIZE_T blk_rem;
895  CPU_SIZE_T i;
896  CPU_SR_ALLOC();
897 
898 
899 /*$PAGE*/
900  /* Init octets req'd for err (see Note #4). */
901  if (poctets_reqd != (CPU_SIZE_T *)0) {
902  *poctets_reqd = (CPU_SIZE_T )0;
903  }
904 
905 
906  Mem_PoolClr(pmem_pool, perr); /* Init mem pool for err (see Note #4). */
907  if (*perr != LIB_MEM_ERR_NONE) {
908  return;
909  }
910 
911 
912  /* ----------- VALIDATE MEM POOL CREATE ----------- */
913 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
914  if (pmem_base_addr != (void *)0) {
915  if (mem_size < 1) {
916  *perr = LIB_MEM_ERR_INVALID_SEG_SIZE;
917  return;
918  }
919  }
920 
921  if (blk_nbr < 1) {
922  *perr = LIB_MEM_ERR_INVALID_BLK_NBR;
923  return;
924  }
925 
926  if (blk_size < 1) {
927  *perr = LIB_MEM_ERR_INVALID_BLK_SIZE;
928  return;
929  }
930 #endif
931 
932  if (blk_align < 1) {
933  blk_align = 1;
934  }
935 
936  /* ------------ VALIDATE MEM POOL TBL ------------- */
937  if (Mem_PoolTbl == (MEM_POOL *)0) {
938  *perr = LIB_MEM_ERR_HEAP_NOT_FOUND;
939  return;
940  }
941 
942 
943 
944 /*$PAGE*/
945  /* ---------------- CREATE MEM POOL --------------- */
946  pmem_pool_heap = (MEM_POOL *)&Mem_PoolHeap;
947 
948  CPU_CRITICAL_ENTER();
949 
950  if (pmem_base_addr == (void *)0) { /* If no base addr, cfg mem pool from heap. */
951  pmem_pool_blk = pmem_pool_heap;
952  pmem_pool_prev = pmem_pool_heap;
953  pmem_pool_next = pmem_pool_heap;
954 
955  /* --------------- VALIDATE MEM SEG --------------- */
956  /* Calc tot mem size for mem pool ptrs. */
957  pmem_addr_ptrs = (CPU_INT08U *)pmem_pool_heap->SegAddrNextAvail;
958  size_tot_ptrs = Mem_PoolSegCalcTotSize((void *)pmem_addr_ptrs,
959  (CPU_SIZE_T)blk_nbr,
960  (CPU_SIZE_T)sizeof(void *),
961  (CPU_SIZE_T)sizeof(void *));
962  /* Calc tot mem size for mem blks. */
963  pmem_addr_pool = pmem_addr_ptrs + size_tot_ptrs; /* Adj next avail addr for mem pool blks. */
964  size_tot_pool = Mem_PoolSegCalcTotSize((void *)pmem_addr_pool,
965  (CPU_SIZE_T)blk_nbr,
966  (CPU_SIZE_T)blk_size,
967  (CPU_SIZE_T)blk_align);
968 
969  size_tot = size_tot_ptrs + size_tot_pool;
970  size_rem = pmem_pool_heap->SegSizeRem;
971 
972  if (size_tot > size_rem) { /* If tot size > rem size, ... */
973  CPU_CRITICAL_EXIT();
974  *perr = LIB_MEM_ERR_HEAP_EMPTY;
975  if (poctets_reqd != (CPU_SIZE_T *)0) {
976  *poctets_reqd = size_tot - size_rem; /* ... rtn add'l heap size needed. */
977  }
978  return;
979  }
980 
981 
982  } else { /* Else cfg mem pool from dedicated mem. */
983  /* -------- SRCH ALL MEM SEGS FOR MEM POOL -------- */
984  pmem_base_addr_start = (CPU_INT08U *)pmem_base_addr;
985  pmem_base_addr_end = (CPU_INT08U *)pmem_base_addr + mem_size - 1;
986 
987  pmem_pool_blk = (MEM_POOL *)0;
988  pmem_pool_prev = (MEM_POOL *)0;
989  pmem_pool_next = Mem_PoolTbl;
990 
991  while (pmem_pool_next != (MEM_POOL *)0) { /* Srch tbl for mem seg with same base addr/size. */
992 
993  if ((pmem_base_addr == pmem_pool_next->SegAddr) &&
994  (mem_size == pmem_pool_next->SegSizeTot)) {
995 
996  pmem_pool_blk = pmem_pool_next;
997  pmem_pool_prev = pmem_pool_next;
998  break;
999 
1000  } else {
1001  pmem_seg_addr_start = (CPU_INT08U *)pmem_pool_next->SegAddr;
1002  pmem_seg_addr_end = (CPU_INT08U *)pmem_pool_next->SegAddr + pmem_pool_next->SegSizeTot - 1;
1003 
1004  /* Seg not found. */
1005  if (pmem_base_addr_end < pmem_seg_addr_start) {
1006  break;
1007 
1008  /* New mem seg overlaps cur mem seg. */
1009  } else if (((pmem_base_addr_start <= pmem_seg_addr_start) &&
1010  (pmem_base_addr_end >= pmem_seg_addr_start)) ||
1011  ((pmem_base_addr_start >= pmem_seg_addr_start) &&
1012  (pmem_base_addr_end <= pmem_seg_addr_end )) ||
1013  ((pmem_base_addr_start <= pmem_seg_addr_end ) &&
1014  (pmem_base_addr_end >= pmem_seg_addr_end ))) {
1015  CPU_CRITICAL_EXIT();
1016  *perr = LIB_MEM_ERR_INVALID_SEG_OVERLAP;
1017  return;
1018  }
1019  }
1020  /* If mem seg NOT found, adv to next mem seg. */
1021  pmem_pool_prev = pmem_pool_next;
1022  pmem_pool_next = pmem_pool_next->SegNextPtr;
1023  }
1024 
1025  if (pmem_pool_blk == (MEM_POOL *)0) { /* If mem seg NOT found, add new mem seg. */
1026  pmem_pool_blk = pmem_pool;
1027  pmem_pool->SegAddr = pmem_base_addr;
1028  pmem_pool->SegAddrNextAvail = pmem_base_addr;
1029  pmem_pool->SegSizeTot = mem_size;
1030  pmem_pool->SegSizeRem = mem_size;
1031  }
1032 
1033 /*$PAGE*/
1034  /* --------------- VALIDATE MEM SEG --------------- */
1035  /* Calc tot mem size for mem pool ptrs. */
1036  pmem_addr_ptrs = (CPU_INT08U *)pmem_pool_heap->SegAddrNextAvail;
1037  size_tot_ptrs = Mem_PoolSegCalcTotSize((void *)pmem_addr_ptrs,
1038  (CPU_SIZE_T)blk_nbr,
1039  (CPU_SIZE_T)sizeof(void *),
1040  (CPU_SIZE_T)sizeof(void *));
1041  size_rem = pmem_pool_heap->SegSizeRem;
1042 
1043  if (size_tot_ptrs > size_rem) { /* If ptr size > rem size, ... */
1044  CPU_CRITICAL_EXIT();
1045  *perr = LIB_MEM_ERR_HEAP_EMPTY;
1046  if (poctets_reqd != (CPU_SIZE_T *)0) {
1047  *poctets_reqd = size_tot_ptrs - size_rem; /* ... rtn add'l heap size needed. */
1048  }
1049  return;
1050  }
1051 
1052  /* Calc tot mem size for mem blks. */
1053  pmem_addr_pool = (CPU_INT08U *)pmem_pool_blk->SegAddrNextAvail;
1054  size_tot_pool = Mem_PoolSegCalcTotSize((void *)pmem_addr_pool,
1055  (CPU_SIZE_T)blk_nbr,
1056  (CPU_SIZE_T)blk_size,
1057  (CPU_SIZE_T)blk_align);
1058  size_rem = pmem_pool_blk->SegSizeRem;
1059 
1060  if (size_tot_pool > size_rem) { /* If tot size > rem size, ... */
1061  CPU_CRITICAL_EXIT();
1062  *perr = LIB_MEM_ERR_SEG_EMPTY;
1063  if (poctets_reqd != (CPU_SIZE_T *)0) {
1064  *poctets_reqd = size_tot_pool - size_rem; /* ... rtn add'l seg size needed. */
1065  }
1066  return;
1067  }
1068  }
1069 
1070 
1071  /* ---------------- ALLOC MEM BLKs ---------------- */
1072  size_pool_ptrs = blk_nbr * sizeof(void *);
1073  /* Alloc stk of ptrs for mem blks from heap. */
1074  ppool_ptr = (void **)Mem_PoolSegAlloc((MEM_POOL *)pmem_pool_heap,
1075  (CPU_SIZE_T)size_pool_ptrs,
1076  (CPU_SIZE_T)sizeof(void *));
1077  if (ppool_ptr == (void **)0) { /* If mem pool ptrs alloc failed, ... */
1078  size_rem = pmem_pool_heap->SegSizeRem;
1079  CPU_CRITICAL_EXIT();
1080  *perr = LIB_MEM_ERR_HEAP_EMPTY;
1081  if (poctets_reqd != (CPU_SIZE_T *)0) { /* ... rtn add'l heap size needed. */
1082  if (pmem_base_addr == (void *)0) {
1083  if (size_tot > size_rem) {
1084  *poctets_reqd = size_tot - size_rem;
1085  } else {
1086  *poctets_reqd = size_tot;
1087  }
1088  } else {
1089  if (size_pool_ptrs > size_rem) {
1090  *poctets_reqd = size_pool_ptrs - size_rem;
1091  } else {
1092  *poctets_reqd = size_pool_ptrs;
1093  }
1094  }
1095  }
1096  return;
1097  }
1098 
1099  for (i = 0; i < blk_nbr; i++) { /* Alloc mem blks from blk seg ptr. */
1100  pmem_blk = (void *)Mem_PoolSegAlloc(pmem_pool_blk, blk_size, blk_align);
1101  if (pmem_blk == (void *)0) { /* If mem blks alloc failed, ... */
1102  pmem_addr_pool = (CPU_INT08U *)pmem_pool_blk->SegAddrNextAvail;
1103  size_rem = (CPU_SIZE_T )pmem_pool_blk->SegSizeRem;
1104  CPU_CRITICAL_EXIT();
1105  *perr = LIB_MEM_ERR_SEG_EMPTY;
1106  if (poctets_reqd != (CPU_SIZE_T *)0) { /* ... rtn add'l seg size needed. */
1107  blk_rem = blk_nbr - i;
1108  size_tot = Mem_PoolSegCalcTotSize((void *)pmem_addr_pool,
1109  (CPU_SIZE_T)blk_rem,
1110  (CPU_SIZE_T)blk_size,
1111  (CPU_SIZE_T)blk_align);
1112  if (size_tot > size_rem) {
1113  *poctets_reqd = size_tot - size_rem;
1114  } else {
1115  *poctets_reqd = size_tot;
1116  }
1117  }
1118  return;
1119  }
1120  ppool_ptr[i] = pmem_blk;
1121  }
1122 
1123 
1124 /*$PAGE*/
1125  /* ------------- UPDATE MEM POOL TBL -------------- */
1126  if (pmem_pool_prev == pmem_pool_next) { /* Add new mem seg to list. */
1127 
1128  pmem_pool_next = pmem_pool_blk->PoolNextPtr;
1129  pmem_pool->PoolPrevPtr = pmem_pool_blk;
1130  pmem_pool->PoolNextPtr = pmem_pool_next;
1131  pmem_pool_blk->PoolNextPtr = pmem_pool;
1132  if (pmem_pool_next != (MEM_POOL *)0) {
1133  pmem_pool_next->PoolPrevPtr = pmem_pool;
1134  }
1135 
1136  } else { /* Add new mem pool to mem seg. */
1137 
1138  pmem_pool->SegPrevPtr = pmem_pool_prev;
1139  pmem_pool->SegNextPtr = pmem_pool_next;
1140 
1141  if (pmem_pool_prev != (MEM_POOL *)0) { /* Update prev mem pool link. */
1142  pmem_pool_prev->SegNextPtr = pmem_pool;
1143  } else {
1144  Mem_PoolTbl = pmem_pool; /* Update mem pool head. */
1145  }
1146 
1147  if (pmem_pool_next != (MEM_POOL *)0) { /* Update next mem pool link. */
1148  pmem_pool_next->SegPrevPtr = pmem_pool;
1149  }
1150  }
1151 
1152 
1153  /* ----------------- CFG MEM POOL ----------------- */
1154  pmem_pool->Type = (LIB_MEM_TYPE) LIB_MEM_TYPE_POOL;
1155  pmem_pool->PoolAddrStart = (void *) pmem_addr_pool;
1156  pmem_pool->PoolAddrEnd = (void *)(pmem_addr_pool + size_tot_pool - 1);
1157  pmem_pool->PoolPtrs = (void **) ppool_ptr;
1158  pmem_pool->PoolSize = (CPU_SIZE_T ) size_tot_pool;
1159  pmem_pool->BlkAlign = (CPU_SIZE_T ) blk_align;
1160  pmem_pool->BlkSize = (CPU_SIZE_T ) blk_size;
1161  pmem_pool->BlkNbr = (CPU_SIZE_T ) blk_nbr;
1162  pmem_pool->BlkIx = (MEM_POOL_IX ) blk_nbr;
1163 
1164 
1165  CPU_CRITICAL_EXIT();
1166 
1167  *perr = LIB_MEM_ERR_NONE;
1168 }

函数调用图:

void* Mem_PoolBlkGet ( MEM_POOL *  pmem_pool,
CPU_SIZE_T  size,
LIB_ERR *  perr 
)

在文件 lib_mem.c 第 1204 行定义.

参考 CPU_CRITICAL_ENTER, CPU_CRITICAL_EXIT, CPU_SR_ALLOC, LIB_MEM_ERR_INVALID_BLK_IX, LIB_MEM_ERR_INVALID_BLK_SIZE, LIB_MEM_ERR_INVALID_POOL, LIB_MEM_ERR_NONE, LIB_MEM_ERR_NULL_PTR, LIB_MEM_ERR_POOL_EMPTY , 以及 LIB_MEM_TYPE_POOL.

1207 {
1208  void *pmem_blk;
1209  CPU_SR_ALLOC();
1210 
1211  /* ------------ VALIDATE MEM POOL GET ------------- */
1212 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1213  if (pmem_pool == (MEM_POOL *)0) {
1214  *perr = LIB_MEM_ERR_NULL_PTR;
1215  return ((void *)0);
1216  }
1217 #endif
1218 
1219  CPU_CRITICAL_ENTER();
1220 
1221 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1222  if (pmem_pool->Type != LIB_MEM_TYPE_POOL) {
1223  CPU_CRITICAL_EXIT();
1224  *perr = LIB_MEM_ERR_INVALID_POOL;
1225  return ((void *)0);
1226  }
1227 
1228  if (size > pmem_pool->BlkSize) {
1229  CPU_CRITICAL_EXIT();
1230  *perr = LIB_MEM_ERR_INVALID_BLK_SIZE;
1231  return ((void *)0);
1232  }
1233 #endif
1234 
1235  if (pmem_pool->BlkIx < 1) {
1236  CPU_CRITICAL_EXIT();
1237  *perr = LIB_MEM_ERR_POOL_EMPTY;
1238  return ((void *)0);
1239  }
1240 
1241  if (pmem_pool->BlkIx > pmem_pool->BlkNbr) {
1242  CPU_CRITICAL_EXIT();
1243  *perr = LIB_MEM_ERR_INVALID_BLK_IX;
1244  return ((void *)0);
1245  }
1246 
1247  /* ------------ GET MEM BLK FROM POOL ------------- */
1248  pmem_pool->BlkIx--;
1249  pmem_blk = pmem_pool->PoolPtrs[pmem_pool->BlkIx];
1250 
1251  CPU_CRITICAL_EXIT();
1252 
1253  *perr = LIB_MEM_ERR_NONE;
1254 
1255  return (pmem_blk);
1256 }
void Mem_PoolBlkFree ( MEM_POOL *  pmem_pool,
void *  pmem_blk,
LIB_ERR *  perr 
)

在文件 lib_mem.c 第 1293 行定义.

参考 CPU_CRITICAL_ENTER, CPU_CRITICAL_EXIT, CPU_SR_ALLOC, DEF_OK, LIB_MEM_ERR_INVALID_BLK_ADDR, LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL, LIB_MEM_ERR_INVALID_POOL, LIB_MEM_ERR_NONE, LIB_MEM_ERR_NULL_PTR, LIB_MEM_ERR_POOL_FULL, LIB_MEM_TYPE_POOL , 以及 Mem_PoolBlkIsValidAddr().

1296 {
1297 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1298  CPU_BOOLEAN addr_valid;
1299  MEM_POOL_IX i;
1300 #endif
1301  CPU_SR_ALLOC();
1302 
1303  /* ------------ VALIDATE MEM POOL FREE ------------ */
1304 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1305  if (pmem_pool == (MEM_POOL *)0) {
1306  *perr = LIB_MEM_ERR_NULL_PTR;
1307  return;
1308  }
1309 
1310  if (pmem_blk == (void *)0) {
1311  *perr = LIB_MEM_ERR_NULL_PTR;
1312  return;
1313  }
1314 #endif
1315 
1316  CPU_CRITICAL_ENTER();
1317 
1318 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1319  if (pmem_pool->Type != LIB_MEM_TYPE_POOL) {
1320  CPU_CRITICAL_EXIT();
1321  *perr = LIB_MEM_ERR_INVALID_POOL;
1322  return;
1323  }
1324 #endif
1325 
1326  if (pmem_pool->BlkIx >= pmem_pool->BlkNbr) {
1327  CPU_CRITICAL_EXIT();
1328  *perr = LIB_MEM_ERR_POOL_FULL;
1329  return;
1330  }
1331 
1332 #if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
1333  addr_valid = Mem_PoolBlkIsValidAddr(pmem_pool, pmem_blk);
1334  if (addr_valid != DEF_OK) {
1335  CPU_CRITICAL_EXIT();
1336  *perr = LIB_MEM_ERR_INVALID_BLK_ADDR;
1337  return;
1338  }
1339 
1340  for (i = 0; i < pmem_pool->BlkIx; i++) {
1341  if (pmem_blk == pmem_pool->PoolPtrs[i]) {
1342  CPU_CRITICAL_EXIT();
1343  *perr = LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL;
1344  return;
1345  }
1346  }
1347 #endif
1348 
1349  /* ------------- FREE MEM BLK TO POOL ------------- */
1350  pmem_pool->PoolPtrs[pmem_pool->BlkIx] = pmem_blk;
1351  pmem_pool->BlkIx++;
1352 
1353  CPU_CRITICAL_EXIT();
1354 
1355  *perr = LIB_MEM_ERR_NONE;
1356 }

函数调用图: