UCOS_TI_LM3S_Keil
 全部 结构体 文件 函数 变量 类型定义 宏定义 页
宏定义 | 函数 | 变量
lib_mem.c 文件参考
#include <lib_mem.h>
lib_mem.c 的引用(Include)关系图:

浏览源代码.

宏定义

#define LIB_MEM_MODULE
 

函数

static CPU_BOOLEAN Mem_PoolBlkIsValidAddr (MEM_POOL *pmem_pool, void *pmem_blk)
 
static CPU_SIZE_T Mem_PoolSegCalcTotSize (void *pmem_addr, CPU_SIZE_T blk_nbr, CPU_SIZE_T blk_size, CPU_SIZE_T blk_align)
 
static void * Mem_PoolSegAlloc (MEM_POOL *pmem_pool, CPU_SIZE_T size, CPU_SIZE_T align)
 
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)
 
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)
 

变量

MEM_POOL * Mem_PoolTbl
 
MEM_POOL Mem_PoolHeap
 
CPU_INT08U Mem_Heap [LIB_MEM_CFG_HEAP_SIZE]
 

宏定义说明

#define LIB_MEM_MODULE

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

函数说明

static CPU_BOOLEAN Mem_PoolBlkIsValidAddr ( MEM_POOL *  pmem_pool,
void *  pmem_blk 
)
static

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

参考 DEF_NO , 以及 DEF_YES.

参考自 Mem_PoolBlkFree().

1395 {
1396  CPU_INT08U *ppool_addr_first;
1397  void *ppool_addr_start;
1398  void *ppool_addr_end;
1399  CPU_SIZE_T align_offset;
1400  CPU_SIZE_T blk_align;
1401  CPU_SIZE_T blk_align_offset;
1402  CPU_SIZE_T blk_size;
1403  CPU_SIZE_T mem_align;
1404  CPU_SIZE_T mem_align_offset;
1405  CPU_SIZE_T mem_diff;
1406  CPU_BOOLEAN addr_valid;
1407 
1408 
1409  ppool_addr_start = pmem_pool->PoolAddrStart;
1410  ppool_addr_end = pmem_pool->PoolAddrEnd;
1411 
1412  if ((pmem_blk < ppool_addr_start) ||
1413  (pmem_blk > ppool_addr_end)) {
1414  return (DEF_NO);
1415  }
1416 
1417  blk_align = (CPU_SIZE_T)pmem_pool->BlkAlign;
1418  align_offset = (CPU_SIZE_T)((CPU_ADDR)ppool_addr_start % blk_align);
1419  if (align_offset != 0) {
1420  mem_align_offset = blk_align - align_offset;
1421  } else {
1422  mem_align_offset = 0;
1423  }
1424 
1425  blk_size = pmem_pool->BlkSize;
1426  align_offset = blk_size % blk_align;
1427  if (align_offset != 0) {
1428  blk_align_offset = blk_align - align_offset;
1429  } else {
1430  blk_align_offset = 0;
1431  }
1432 
1433  ppool_addr_first = (CPU_INT08U *)((CPU_INT08U *)ppool_addr_start + mem_align_offset);
1434  mem_diff = (CPU_SIZE_T )((CPU_INT08U *)pmem_blk - ppool_addr_first);
1435  mem_align = (CPU_SIZE_T )( blk_size + blk_align_offset);
1436 
1437  addr_valid = ((mem_diff % mem_align) == 0) ? DEF_YES : DEF_NO;
1438 
1439  return (addr_valid);
1440 }

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

static CPU_SIZE_T Mem_PoolSegCalcTotSize ( void *  pmem_addr,
CPU_SIZE_T  blk_nbr,
CPU_SIZE_T  blk_size,
CPU_SIZE_T  blk_align 
)
static

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

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

1547 {
1548  CPU_SIZE_T align_offset;
1549  CPU_SIZE_T mem_align_offset;
1550  CPU_SIZE_T blk_align_offset;
1551  CPU_SIZE_T size_tot;
1552 
1553  /* Calc mem align (see Note #2a). */
1554  align_offset = (CPU_ADDR)pmem_addr % blk_align;
1555  if (align_offset != 0) {
1556  mem_align_offset = blk_align - align_offset;
1557  } else {
1558  mem_align_offset = 0;
1559  }
1560  /* Calc blk align (see Note #2b). */
1561  align_offset = blk_size % blk_align;
1562  if (align_offset != 0) {
1563  blk_align_offset = blk_align - align_offset;
1564  } else {
1565  blk_align_offset = 0;
1566  }
1567  /* Calc tot size (see Note #2c). */
1568  size_tot = mem_align_offset + ((blk_size + blk_align_offset) * (blk_nbr - 1)) + blk_size;
1569 
1570  return (size_tot);
1571 }

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

static void * Mem_PoolSegAlloc ( MEM_POOL *  pmem_pool,
CPU_SIZE_T  size,
CPU_SIZE_T  align 
)
static

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

参考 CPU_CRITICAL_ENTER, CPU_CRITICAL_EXIT , 以及 CPU_SR_ALLOC.

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

1609 {
1610  CPU_INT08U *pmem_addr;
1611  CPU_SIZE_T mem_align;
1612  CPU_SIZE_T align_offset;
1613  CPU_SIZE_T size_tot;
1614  CPU_SIZE_T size_rem;
1615  CPU_SR_ALLOC();
1616 
1617 
1618  CPU_CRITICAL_ENTER();
1619  pmem_addr = (CPU_INT08U *)pmem_pool->SegAddrNextAvail;
1620 
1621  mem_align = (CPU_SIZE_T )((CPU_ADDR)pmem_addr % align); /* Calc mem align. */
1622 
1623  if (mem_align != 0) {
1624  align_offset = align - mem_align;
1625  } else {
1626  align_offset = 0;
1627  }
1628 
1629  size_tot = align_offset + size;
1630  size_rem = pmem_pool->SegSizeRem;
1631 
1632  if (size_tot > size_rem) { /* If insufficiemt mem seg size rem, ... */
1633  CPU_CRITICAL_EXIT();
1634  return ((void *)0); /* ... rtn NULL. */
1635  }
1636 
1637  pmem_addr += align_offset; /* Adj mem addr align. */
1638 
1639  pmem_pool->SegAddrNextAvail = pmem_addr + size; /* Adv next avail addr. */
1640  pmem_pool->SegSizeRem -= size_tot; /* Adj rem mem seg size. */
1641 
1642  CPU_CRITICAL_EXIT();
1643 
1644  return ((void *)pmem_addr);
1645 }

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

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 }

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

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 }

函数调用图:

变量说明

MEM_POOL* Mem_PoolTbl

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

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

MEM_POOL Mem_PoolHeap

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

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

CPU_INT08U Mem_Heap[LIB_MEM_CFG_HEAP_SIZE]

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

参考自 Mem_Init().