📄 lib_mem.c
字号:
*
* (4) Modulo arithmetic is used to determine whether a memory buffer starts on a 'CPU_ALIGN'
* address boundary.
*
* Modulo arithmetic in ANSI-C REQUIREs operations performed on integer values. Thus,
* address values MUST be cast to an appropriately-sized integer value PRIOR to any
* mem_align_modulo arithmetic operation.
*********************************************************************************************************
*/
/*$PAGE*/
#if ((!defined(uC_CFG_OPTIMIZE_ASM_EN)) || \
((defined(uC_CFG_OPTIMIZE_ASM_EN)) && \
(uC_CFG_OPTIMIZE_ASM_EN != DEF_ENABLED)))
void Mem_Copy (void *pdest,
void *psrc,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_ALIGN *pmem_align_dest;
CPU_ALIGN *pmem_align_src;
CPU_INT08U *pmem_08_dest;
CPU_INT08U *pmem_08_src;
CPU_INT08U i;
CPU_INT08U mem_align_modulo_dest;
CPU_INT08U mem_align_modulo_src;
CPU_BOOLEAN mem_aligned;
if (size < 1) { /* See Note #1. */
return;
}
if (pdest == (void *)0) {
return;
}
if (psrc == (void *)0) {
return;
}
size_rem = (CPU_SIZE_T )size;
pmem_08_dest = (CPU_INT08U *)pdest;
pmem_08_src = (CPU_INT08U *)psrc;
/* See Note #4. */
mem_align_modulo_dest = (CPU_INT08U )((CPU_ADDR)pmem_08_dest % sizeof(CPU_ALIGN));
mem_align_modulo_src = (CPU_INT08U )((CPU_ADDR)pmem_08_src % sizeof(CPU_ALIGN));
mem_aligned = (mem_align_modulo_dest == mem_align_modulo_src) ? DEF_YES : DEF_NO;
if (mem_aligned == DEF_YES) { /* If mem bufs' alignment offset equal, ... */
/* ... optimize copy for mem buf alignment. */
if (mem_align_modulo_dest != 0) { /* If leading octets avail, ... */
i = mem_align_modulo_dest;
while ((size_rem > 0) && /* ... start mem buf copy with leading octets ... */
(i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
*pmem_08_dest++ = *pmem_08_src++;
size_rem -= sizeof(CPU_INT08U);
i++;
}
}
pmem_align_dest = (CPU_ALIGN *)pmem_08_dest; /* See Note #3a. */
pmem_align_src = (CPU_ALIGN *)pmem_08_src;
while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem bufs aligned on CPU_ALIGN word boundaries, */
*pmem_align_dest++ = *pmem_align_src++; /* ... copy psrc to pdest with CPU_ALIGN-sized words. */
size_rem -= sizeof(CPU_ALIGN);
}
pmem_08_dest = (CPU_INT08U *)pmem_align_dest;
pmem_08_src = (CPU_INT08U *)pmem_align_src;
}
while (size_rem > 0) { /* For unaligned mem bufs or trailing octets, ... */
*pmem_08_dest++ = *pmem_08_src++; /* ... copy psrc to pdest by octets. */
size_rem -= sizeof(CPU_INT08U);
}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* Mem_Cmp()
*
* Description : Verify that ALL data octets in two memory buffers are identical in sequence.
*
* Argument(s) : p1_mem Pointer to first memory buffer.
*
* p2_mem Pointer to second memory buffer.
*
* size Number of data buffer octets to compare.
*
* Return(s) : DEF_YES, if 'size' number of data octets are identical in both memory buffers.
*
* DEF_NO, otherwise.
*
* Caller(s) : various.
*
* Note(s) : (1) Null compares allowed (i.e. 0-octet size); 'DEF_YES' returned to indicate identical
* null compare.
*
* (2) Many memory buffer comparisons vary ONLY in the least significant octets -- e.g.
* network address buffers. Consequently, memory buffer comparison is more efficient
* if the comparison starts from the end of the memory buffers which will abort sooner
* on dissimilar memory buffers that vary only in the least significant octets.
*
* (3) For best CPU performance, optimized to compare data buffers using 'CPU_ALIGN'-sized
* data words.
*
* (a) Since many word-aligned processors REQUIRE that multi-octet words be accessed on
* word-aligned addresses, 'CPU_ALIGN'-sized words MUST be accessed on 'CPU_ALIGN'd
* addresses.
*
* (4) Modulo arithmetic is used to determine whether a memory buffer starts on a 'CPU_ALIGN'
* address boundary.
*
* Modulo arithmetic in ANSI-C REQUIREs operations performed on integer values. Thus,
* address values MUST be cast to an appropriately-sized integer value PRIOR to any
* mem_align_modulo arithmetic operation.
********************************************************************************************************
*/
/*$PAGE*/
CPU_BOOLEAN Mem_Cmp (void *p1_mem,
void *p2_mem,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_ALIGN *p1_mem_align;
CPU_ALIGN *p2_mem_align;
CPU_INT08U *p1_mem_08;
CPU_INT08U *p2_mem_08;
CPU_INT08U i;
CPU_INT08U mem_align_modulo_1;
CPU_INT08U mem_align_modulo_2;
CPU_BOOLEAN mem_aligned;
CPU_BOOLEAN mem_cmp;
if (size < 1) { /* See Note #1. */
return (DEF_YES);
}
if (p1_mem == (void *)0) {
return (DEF_NO);
}
if (p2_mem == (void *)0) {
return (DEF_NO);
}
mem_cmp = DEF_YES; /* Assume mem bufs are identical until cmp fails. */
size_rem = size;
/* Start @ end of mem bufs (see Note #2). */
p1_mem_08 = (CPU_INT08U *)p1_mem + size;
p2_mem_08 = (CPU_INT08U *)p2_mem + size;
/* See Note #4. */
mem_align_modulo_1 = (CPU_INT08U )((CPU_ADDR)p1_mem_08 % sizeof(CPU_ALIGN));
mem_align_modulo_2 = (CPU_INT08U )((CPU_ADDR)p2_mem_08 % sizeof(CPU_ALIGN));
mem_aligned = (mem_align_modulo_1 == mem_align_modulo_2) ? DEF_YES : DEF_NO;
if (mem_aligned == DEF_YES) { /* If mem bufs' alignment offset equal, ... */
/* ... optimize cmp for mem buf alignment. */
if (mem_align_modulo_1 != 0) { /* If trailing octets avail, ... */
i = mem_align_modulo_1;
while ((mem_cmp == DEF_YES) && /* ... cmp mem bufs while identical & ... */
(size_rem > 0) && /* ... start mem buf cmp with trailing octets ... */
(i > 0)) { /* ... until next CPU_ALIGN word boundary. */
p1_mem_08--;
p2_mem_08--;
if (*p1_mem_08 != *p2_mem_08) { /* If ANY data octet(s) NOT identical, cmp fails. */
mem_cmp = DEF_NO;
}
size_rem -= sizeof(CPU_INT08U);
i--;
}
}
if (mem_cmp == DEF_YES) { /* If cmp still identical, cmp aligned mem bufs. */
p1_mem_align = (CPU_ALIGN *)p1_mem_08; /* See Note #3a. */
p2_mem_align = (CPU_ALIGN *)p2_mem_08;
while ((mem_cmp == DEF_YES) && /* Cmp mem bufs while identical & ... */
(size_rem >= sizeof(CPU_ALIGN))) { /* ... mem bufs aligned on CPU_ALIGN word boundaries. */
p1_mem_align--;
p2_mem_align--;
if (*p1_mem_align != *p2_mem_align) { /* If ANY data octet(s) NOT identical, cmp fails. */
mem_cmp = DEF_NO;
}
size_rem -= sizeof(CPU_ALIGN);
}
p1_mem_08 = (CPU_INT08U *)p1_mem_align;
p2_mem_08 = (CPU_INT08U *)p2_mem_align;
}
}
while ((mem_cmp == DEF_YES) && /* Cmp mem bufs while identical ... */
(size_rem > 0)) { /* ... for unaligned mem bufs or trailing octets. */
p1_mem_08--;
p2_mem_08--;
if (*p1_mem_08 != *p2_mem_08) { /* If ANY data octet(s) NOT identical, cmp fails. */
mem_cmp = DEF_NO;
}
size_rem -= sizeof(CPU_INT08U);
}
return (mem_cmp);
}
/*$PAGE*/
/*
*********************************************************************************************************
* Mem_PoolCreate()
*
* Description : Create a memory pool.
*
* Argument(s) : pmem_base_addr Memory pool base address :
*
* Null (0) address Memory pool allocated from general-purpose
* heap.
* Non-null address Memory pool allocated from specified base
* address of dedicated memory.
*
* mem_size Size of memory pool segment (in octets).
*
* blk_nbr Number of memory pool blocks to initialize.
*
* blk_size Size of memory pool blocks to initialize (in octets).
*
* blk_align Alignment of memory pool blocks to initialize (in octets).
*
* pmem_pool Pointer to a memory pool structure to be created.
*
* poctets_reqd Pointer to a variable to ... :
*
* (a) Return the number of octets required to successfully
* allocate the memory pool, if any errors;
* (b) Return 0, otherwise.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* LIB_ERR_NONE Memory pool successfully initialized.
*
* Return(s) : none.
*
* Caller(s) : various.
*
* Note(s) : (2) Pointers to variables that return values MUST be initialized to return PRIOR to all
* other validation or function handling in case of any error(s).
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_POOL_EN == DEF_ENABLED)
void Mem_PoolCreate (void *pmem_base_addr,
CPU_SIZE_T mem_size,
CPU_SIZE_T blk_nbr,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
MEM_POOL *pmem_pool,
CPU_SIZE_T *poctets_reqd,
LIB_ERR *perr)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
MEM_POOL *pmem_pool_heap;
MEM_POOL *pmem_pool_prev;
MEM_POOL *pmem_pool_next;
MEM_POOL *pmem_pool_blk;
void **ppool_ptr;
void *pmem_blk;
CPU_INT08U *pmem_addr_ptrs;
CPU_INT08U *pmem_addr_pool;
CPU_INT08U *pmem_base_addr_start;
CPU_INT08U *pmem_base_addr_end;
CPU_INT08U *pmem_seg_addr_start;
CPU_INT08U *pmem_seg_addr_end;
CPU_SIZE_T tot_size;
CPU_SIZE_T tot_size_ptrs;
CPU_SIZE_T tot_size_pool;
CPU_SIZE_T size_rem;
CPU_SIZE_T size_pool_ptrs;
CPU_SIZE_T i;
/* Init rem'ing octets for err (see Note #2). */
if (poctets_reqd != (CPU_SIZE_T *)0) {
*poctets_reqd = (CPU_SIZE_T )0;
}
if (pmem_pool != (MEM_POOL *)0) {
/* Init mem pool for err (see Note #2). */
pmem_pool->Type = (LIB_MEM_TYPE)LIB_MEM_TYPE_NONE;
pmem_pool->PoolAddrStart = (void *)0;
pmem_pool->PoolAddrEnd = (void *)0;
pmem_pool->PoolPtrs = (void **)0;
pmem_pool->PoolSize = (CPU_SIZE_T )0;
pmem_pool->BlkAlign = (CPU_SIZE_T )0;
pmem_pool->BlkSize = (CPU_SIZE_T )0;
pmem_pool->BlkNbr = (CPU_SIZE_T )0;
pmem_pool->BlkIx = (MEM_POOL_IX )0;
pmem_pool->SegAddr = (void *)0;
pmem_pool->SegAddrNextAvail = (void *)0;
pmem_pool->SegSizeTot = (CPU_SIZE_T )0;
pmem_pool->SegSizeRem = (CPU_SIZE_T )0;
pmem_pool->SegPrimListPrevPtr = (MEM_POOL *)0;
pmem_pool->SegPrimListNextPtr = (MEM_POOL *)0;
pmem_pool->SegSecListPrevPtr = (MEM_POOL *)0;
pmem_pool->SegSecListNextPtr = (MEM_POOL *)0;
} else {
*perr = LIB_MEM_ERR_NULL_PTR;
return;
}
/* -------------- VALIDATE MEM POOL ARGS -------------- */
if (blk_nbr < 1) {
*perr = LIB_MEM_ERR_INVALID_NBR;
return;
}
if (blk_size < 1) {
*perr = LIB_MEM_ERR_INVALID_BLK_SIZE;
return;
}
if (blk_align < 1) {
blk_align = 1;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -