Bluesun
/
BCU
forked from gary/BCU
2
0
Fork 0
Code Pull Requests Activity
BCU/library/ucos/uC-LIB/lib_mem.c

2845 lines
116 KiB
C
Raw Permalink Blame History

/*
*********************************************************************************************************
* uC/LIB
* Custom Library Modules
*
* Copyright 2004-2020 Silicon Laboratories Inc. www.silabs.com
*
* SPDX-License-Identifier: APACHE-2.0
*
* This software is subject to an open source license and is distributed by
* Silicon Laboratories Inc. pursuant to the terms of the Apache License,
* Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
*
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*
* STANDARD MEMORY OPERATIONS
*
* Filename : lib_mem.c
* Version : V1.39.00
*********************************************************************************************************
* Note(s) : (1) NO compiler-supplied standard library functions are used in library or product software.
*
* (a) ALL standard library functions are implemented in the custom library modules :
*
* (1) \<Custom Library Directory>\lib_*.*
*
* (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
*
* where
* <Custom Library Directory> directory path for custom library software
* <cpu> directory name for specific processor (CPU)
* <compiler> directory name for specific compiler
*
* (b) Product-specific library functions are implemented in individual products.
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* INCLUDE FILES
*********************************************************************************************************
*/
#define MICRIUM_SOURCE
#define LIB_MEM_MODULE
#include "lib_mem.h"
#include "lib_math.h"
#include "lib_str.h"
/*
*********************************************************************************************************
* LOCAL DEFINES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* LOCAL CONSTANTS
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* LOCAL DATA TYPES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* LOCAL TABLES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* LOCAL GLOBAL VARIABLES
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
#ifndef LIB_MEM_CFG_HEAP_BASE_ADDR
CPU_INT08U Mem_Heap[LIB_MEM_CFG_HEAP_SIZE]; /* Mem heap. */
#endif
MEM_SEG Mem_SegHeap; /* Heap mem seg. */
#endif
MEM_SEG *Mem_SegHeadPtr; /* Ptr to head of seg list. */
/*
*********************************************************************************************************
* LOCAL FUNCTION PROTOTYPES
*********************************************************************************************************
*/
static void Mem_SegCreateCritical (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_ADDR seg_base_addr,
CPU_SIZE_T padding_align,
CPU_SIZE_T size);
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
static MEM_SEG *Mem_SegOverlapChkCritical( CPU_ADDR seg_base_addr,
CPU_SIZE_T size,
LIB_ERR *p_err);
#endif
static void *Mem_SegAllocInternal (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T padding_align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err);
static void *Mem_SegAllocExtCritical ( MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T padding_align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err);
static void Mem_DynPoolCreateInternal(const CPU_CHAR *p_name,
MEM_DYN_POOL *p_pool,
MEM_SEG *p_seg,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
CPU_SIZE_T blk_padding_align,
CPU_SIZE_T blk_qty_init,
CPU_SIZE_T blk_qty_max,
LIB_ERR *p_err);
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
static void Mem_SegAllocTrackCritical(const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
LIB_ERR *p_err);
#endif
#if ((LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) && \
(LIB_MEM_CFG_HEAP_SIZE > 0u))
static CPU_BOOLEAN Mem_PoolBlkIsValidAddr ( MEM_POOL *p_pool,
void *p_mem);
#endif
/*
*********************************************************************************************************
* LOCAL CONFIGURATION ERRORS
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*********************************************************************************************************
* GLOBAL FUNCTIONS
*********************************************************************************************************
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* Mem_Init()
*
* Description : (1) Initializes Memory Management Module :
*
* (a) Initialize heap memory pool
* (b) Initialize memory pool table
*
*
* Argument(s) : none.
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (2) Mem_Init() MUST be called ... :
*
* (a) ONLY ONCE from a product's application; ...
* (b) BEFORE product's application calls any memory library module function(s)
*********************************************************************************************************
*/
void Mem_Init (void)
{
/* ------------------ INIT SEG LIST ------------------- */
Mem_SegHeadPtr = DEF_NULL;
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
{
LIB_ERR err;
CPU_ADDR heap_base_addr;
/* ------------------ INIT HEAP SEG ------------------- */
#ifdef LIB_MEM_CFG_HEAP_BASE_ADDR
heap_base_addr = LIB_MEM_CFG_HEAP_BASE_ADDR;
#else
heap_base_addr = (CPU_ADDR)&Mem_Heap[0u];
#endif
Mem_SegCreate("Heap",
&Mem_SegHeap, /* Create heap seg. */
heap_base_addr,
LIB_MEM_CFG_HEAP_SIZE,
LIB_MEM_PADDING_ALIGN_NONE,
&err);
if (err != LIB_MEM_ERR_NONE) {
CPU_SW_EXCEPTION(;);
}
}
#endif
}
/*
*********************************************************************************************************
* Mem_Clr()
*
* Description : Clears data buffer (see Note #2).
*
* Argument(s) : pmem Pointer to memory buffer to clear.
*
* size Number of data buffer octets to clear (see Note #1).
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) Null clears allowed (i.e. zero-length clears).
*
* See also 'Mem_Set() Note #1'.
*
* (2) Clear data by setting each data octet to 0.
*********************************************************************************************************
*/
void Mem_Clr (void *pmem,
CPU_SIZE_T size)
{
Mem_Set(pmem,
0u, /* See Note #2. */
size);
}
/*
*********************************************************************************************************
* Mem_Set()
*
* Description : Fills data buffer with specified data octet.
*
* Argument(s) : pmem Pointer to memory buffer to fill with specified data octet.
*
* data_val Data fill octet value.
*
* size Number of data buffer octets to fill (see Note #1).
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) Null sets allowed (i.e. zero-length sets).
*
* (2) For best CPU performance, optimized to fill data buffer using 'CPU_ALIGN'-sized data
* words. 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.
*
* (3) 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_mod' arithmetic operation.
*********************************************************************************************************
*/
void Mem_Set (void *pmem,
CPU_INT08U data_val,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_ALIGN data_align;
CPU_ALIGN *pmem_align;
CPU_INT08U *pmem_08;
CPU_DATA mem_align_mod;
CPU_DATA i;
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (size < 1) { /* See Note #1. */
return;
}
if (pmem == (void *)0) {
return;
}
#endif
data_align = 0u;
for (i = 0u; i < sizeof(CPU_ALIGN); i++) { /* Fill each data_align octet with data val. */
data_align <<= DEF_OCTET_NBR_BITS;
data_align |= (CPU_ALIGN)data_val;
}
size_rem = size;
mem_align_mod = (CPU_INT08U)((CPU_ADDR)pmem % sizeof(CPU_ALIGN)); /* See Note #3. */
pmem_08 = (CPU_INT08U *)pmem;
if (mem_align_mod != 0u) { /* If leading octets avail, ... */
i = mem_align_mod;
while ((size_rem > 0) && /* ... start mem buf fill with leading octets ... */
(i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
*pmem_08++ = data_val;
size_rem -= sizeof(CPU_INT08U);
i++;
}
}
pmem_align = (CPU_ALIGN *)pmem_08; /* See Note #2. */
while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem buf aligned on CPU_ALIGN word boundaries, */
*pmem_align++ = data_align; /* ... fill mem buf with CPU_ALIGN-sized data. */
size_rem -= sizeof(CPU_ALIGN);
}
pmem_08 = (CPU_INT08U *)pmem_align;
while (size_rem > 0) { /* Finish mem buf fill with trailing octets. */
*pmem_08++ = data_val;
size_rem -= sizeof(CPU_INT08U);
}
}
/*
*********************************************************************************************************
* Mem_Copy()
*
* Description : Copies data octets from one memory buffer to another memory buffer.
*
* Argument(s) : pdest Pointer to destination memory buffer.
*
* psrc Pointer to source memory buffer.
*
* size Number of octets to copy (see Note #1).
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) Null copies allowed (i.e. zero-length copies).
*
* (2) Memory buffers NOT checked for overlapping.
*
* (a) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that "if
* copying takes place between objects that overlap, the behavior is undefined".
*
* (b) However, data octets from a source memory buffer at a higher address value SHOULD
* successfully copy to a destination memory buffer at a lower address value even
* if any octets of the memory buffers overlap as long as no individual, atomic CPU
* word copy overlaps.
*
* Since Mem_Copy() performs the data octet copy via 'CPU_ALIGN'-sized words &/or
* octets; & since 'CPU_ALIGN'-sized words MUST be accessed on word-aligned addresses
* (see Note #3b), neither 'CPU_ALIGN'-sized words nor octets at unique addresses can
* ever overlap.
*
* Therefore, Mem_Copy() SHOULD be able to successfully copy overlapping memory
* buffers as long as the source memory buffer is at a higher address value than the
* destination memory buffer.
*
* (3) For best CPU performance, optimized to copy data buffer using 'CPU_ALIGN'-sized data
* words. 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_mod' arithmetic operation.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_OPTIMIZE_ASM_EN != DEF_ENABLED)
void Mem_Copy ( void *pdest,
const void *psrc,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_SIZE_T mem_gap_octets;
CPU_ALIGN *pmem_align_dest;
const CPU_ALIGN *pmem_align_src;
CPU_INT08U *pmem_08_dest;
const CPU_INT08U *pmem_08_src;
CPU_DATA i;
CPU_DATA mem_align_mod_dest;
CPU_DATA mem_align_mod_src;
CPU_BOOLEAN mem_aligned;
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (size < 1) { /* See Note #1. */
return;
}
if (pdest == (void *)0) {
return;
}
if (psrc == (void *)0) {
return;
}
#endif
size_rem = size;
pmem_08_dest = ( CPU_INT08U *)pdest;
pmem_08_src = (const CPU_INT08U *)psrc;
mem_gap_octets = (CPU_SIZE_T)(pmem_08_src - pmem_08_dest);
if (mem_gap_octets >= sizeof(CPU_ALIGN)) { /* Avoid bufs overlap. */
/* See Note #4. */
mem_align_mod_dest = (CPU_INT08U)((CPU_ADDR)pmem_08_dest % sizeof(CPU_ALIGN));
mem_align_mod_src = (CPU_INT08U)((CPU_ADDR)pmem_08_src % sizeof(CPU_ALIGN));
mem_aligned = (mem_align_mod_dest == mem_align_mod_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_mod_dest != 0u) { /* If leading octets avail, ... */
i = mem_align_mod_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 #3. */
pmem_align_src = (const 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 = (const 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
/*
*********************************************************************************************************
* Mem_Move()
*
* Description : Moves data octets from one memory buffer to another memory buffer, or within the same
* memory buffer. Overlapping is correctly handled for all move operations.
*
* Argument(s) : pdest Pointer to destination memory buffer.
*
* psrc Pointer to source memory buffer.
*
* size Number of octets to move (see Note #1).
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) Null move operations allowed (i.e. zero-length).
*
* (2) Memory buffers checked for overlapping.
*
* (3) For best CPU performance, optimized to copy data buffer using 'CPU_ALIGN'-sized data
* words. 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_mod' arithmetic operation.
*********************************************************************************************************
*/
void Mem_Move ( void *pdest,
const void *psrc,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_SIZE_T mem_gap_octets;
CPU_ALIGN *pmem_align_dest;
const CPU_ALIGN *pmem_align_src;
CPU_INT08U *pmem_08_dest;
const CPU_INT08U *pmem_08_src;
CPU_INT08S i;
CPU_DATA mem_align_mod_dest;
CPU_DATA mem_align_mod_src;
CPU_BOOLEAN mem_aligned;
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (size < 1) {
return;
}
if (pdest == (void *)0) {
return;
}
if (psrc == (void *)0) {
return;
}
#endif
pmem_08_src = (const CPU_INT08U *)psrc;
pmem_08_dest = ( CPU_INT08U *)pdest;
if (pmem_08_src > pmem_08_dest) {
Mem_Copy(pdest, psrc, size);
return;
}
size_rem = size;
pmem_08_dest = ( CPU_INT08U *)pdest + size - 1;
pmem_08_src = (const CPU_INT08U *)psrc + size - 1;
mem_gap_octets = (CPU_SIZE_T)(pmem_08_dest - pmem_08_src);
if (mem_gap_octets >= sizeof(CPU_ALIGN)) { /* Avoid bufs overlap. */
/* See Note #4. */
mem_align_mod_dest = (CPU_INT08U)((CPU_ADDR)pmem_08_dest % sizeof(CPU_ALIGN));
mem_align_mod_src = (CPU_INT08U)((CPU_ADDR)pmem_08_src % sizeof(CPU_ALIGN));
mem_aligned = (mem_align_mod_dest == mem_align_mod_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_mod_dest != (sizeof(CPU_ALIGN) - 1)) {/* If leading octets avail, ... */
i = (CPU_INT08S)mem_align_mod_dest;
while ((size_rem > 0) && /* ... start mem buf copy with leading octets ... */
(i >= 0)) { /* ... until next CPU_ALIGN word boundary. */
*pmem_08_dest-- = *pmem_08_src--;
size_rem -= sizeof(CPU_INT08U);
i--;
}
}
/* See Note #3. */
pmem_align_dest = ( CPU_ALIGN *)(((CPU_INT08U *)pmem_08_dest - sizeof(CPU_ALIGN)) + 1);
pmem_align_src = (const CPU_ALIGN *)(((CPU_INT08U *)pmem_08_src - sizeof(CPU_ALIGN)) + 1);
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 + sizeof(CPU_ALIGN) - 1;
pmem_08_src = (const CPU_INT08U *)pmem_align_src + sizeof(CPU_ALIGN) - 1;
}
}
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);
}
}
/*
*********************************************************************************************************
* Mem_Cmp()
*
* Description : Verifies 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 (see Note #1).
*
* Return(s) : DEF_YES, if 'size' number of data octets are identical in both memory buffers.
*
* DEF_NO, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) Null compares allowed (i.e. zero-length compares); '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. 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_mod' arithmetic operation.
*********************************************************************************************************
*/
CPU_BOOLEAN Mem_Cmp (const void *p1_mem,
const void *p2_mem,
CPU_SIZE_T size)
{
CPU_SIZE_T size_rem;
CPU_ALIGN *p1_mem_align;
CPU_ALIGN *p2_mem_align;
const CPU_INT08U *p1_mem_08;
const CPU_INT08U *p2_mem_08;
CPU_DATA i;
CPU_DATA mem_align_mod_1;
CPU_DATA mem_align_mod_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 = (const CPU_INT08U *)p1_mem + size;
p2_mem_08 = (const CPU_INT08U *)p2_mem + size;
/* See Note #4. */
mem_align_mod_1 = (CPU_INT08U)((CPU_ADDR)p1_mem_08 % sizeof(CPU_ALIGN));
mem_align_mod_2 = (CPU_INT08U)((CPU_ADDR)p2_mem_08 % sizeof(CPU_ALIGN));
mem_aligned = (mem_align_mod_1 == mem_align_mod_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_mod_1 != 0u) { /* If trailing octets avail, ... */
i = mem_align_mod_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 #3. */
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);
}
/*
*********************************************************************************************************
* Mem_HeapAlloc()
*
* Description : Allocates a memory block from the heap memory segment.
*
* Argument(s) : size Size of memory block to allocate (in bytes).
*
* align Alignment of memory block to specific word boundary (in bytes).
*
* p_bytes_reqd Optional pointer to a variable to ... :
*
* (a) Return the number of bytes required to successfully
* allocate the memory block, if any error(s);
* (b) Return 0, otherwise.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_HEAP_EMPTY No more memory available on heap.
*
* ---------------------RETURNED BY Mem_SegAllocInternal()---------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
*
* Return(s) : Pointer to memory block, if NO error(s).
*
* Pointer to NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) Pointers to variables that return values MUST be initialized PRIOR to all other
* validation or function handling in case of any error(s).
*
* (2) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_SegAlloc(), Mem_SegAllocExt() or Mem_SegAllocHW() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
void *Mem_HeapAlloc (CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
void *p_mem;
p_mem = Mem_SegAllocInternal(DEF_NULL,
&Mem_SegHeap,
size,
align,
LIB_MEM_CFG_HEAP_PADDING_ALIGN,
p_bytes_reqd,
p_err);
if (*p_err == LIB_MEM_ERR_SEG_OVF) {
*p_err = LIB_MEM_ERR_HEAP_OVF;
}
return (p_mem);
}
#endif
/*
*********************************************************************************************************
* Mem_HeapGetSizeRem()
*
* Description : Gets remaining heap memory size available to allocate.
*
* Argument(s) : align Desired word boundary alignment (in bytes) to return remaining memory size from.
*
* p_err Pointer to variable that will receive the return error code from this function
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* --------------------RETURNED BY Mem_SegRemSizeGet()--------------------
* LIB_MEM_ERR_NULL_PTR Segment data pointer NULL.
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory alignment.
*
* Return(s) : Remaining heap memory size (in bytes), if NO error(s).
*
* 0, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_SegRemSizeGet() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
CPU_SIZE_T Mem_HeapGetSizeRem (CPU_SIZE_T align,
LIB_ERR *p_err)
{
CPU_SIZE_T rem_size;
rem_size = Mem_SegRemSizeGet(&Mem_SegHeap,
align,
DEF_NULL,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return (0u);
}
return (rem_size);
}
#endif
/*
*********************************************************************************************************
* Mem_SegCreate()
*
* Description : Creates a new memory segment to be used for runtime memory allocation.
*
* Argument(s) : p_name Pointer to segment name.
*
* p_seg Pointer to segment data. Must be allocated by caller.
*
* seg_base_addr Address of segment's first byte.
*
* size Total size of segment, in bytes.
*
* padding_align Padding alignment, in bytes, that will be added to any allocated buffer from
* this memory segment. MUST be a power of 2. LIB_MEM_PADDING_ALIGN_NONE
* means no padding.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_INVALID_SEG_SIZE Invalid segment size specified.
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid padding alignment.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
*
* -------------------RETURNED BY Mem_SegOverlapChkCritical()-------------------
* LIB_MEM_ERR_INVALID_SEG_OVERLAP Segment overlaps another existing segment.
* LIB_MEM_ERR_INVALID_SEG_EXISTS Segment already exists.
*
* Return(s) : None.
*
* Caller(s) : Application.
*
* Note(s) : (1) New segments are checked for overlap with existing segments. A critical section needs
* to be maintained during the whole list search and add procedure to prevent a reentrant
* call from creating another segment overlapping with the one being added.
*********************************************************************************************************
*/
void Mem_SegCreate (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_ADDR seg_base_addr,
CPU_SIZE_T size,
CPU_SIZE_T padding_align,
LIB_ERR *p_err)
{
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for null err ptr. */
CPU_SW_EXCEPTION(;);
}
if (p_seg == DEF_NULL) { /* Chk for null seg ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
if (size < 1u) { /* Chk for invalid sized seg. */
*p_err = LIB_MEM_ERR_INVALID_SEG_SIZE;
return;
}
/* Chk for addr space ovf. */
if (seg_base_addr + (size - 1u) < seg_base_addr) {
*p_err = LIB_MEM_ERR_INVALID_SEG_SIZE;
return;
}
if ((padding_align != LIB_MEM_PADDING_ALIGN_NONE) &&
(MATH_IS_PWR2(padding_align) != DEF_YES)) {
*p_err = LIB_MEM_ERR_INVALID_MEM_ALIGN;
return;
}
#endif
CPU_CRITICAL_ENTER();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) && \
(LIB_MEM_CFG_HEAP_SIZE > 0u)
(void)Mem_SegOverlapChkCritical(seg_base_addr, /* Chk for overlap. */
size,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
CPU_CRITICAL_EXIT();
return;
}
#endif
Mem_SegCreateCritical(p_name, /* Create seg. */
p_seg,
seg_base_addr,
padding_align,
size);
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
}
/*
*********************************************************************************************************
* Mem_SegClr()
*
* Description : Clears a memory segment.
*
* Argument(s) : p_seg Pointer to segment data. Must be allocated by caller.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Segment data pointer NULL.
*
* Return(s) : None.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function must be used with extreme caution. It must only be called on memory
* segments that are no longer used.
*
* (2) This function is disabled when debug mode is enabled to avoid heap memory leaks.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_DISABLED)
void Mem_SegClr (MEM_SEG *p_seg,
LIB_ERR *p_err)
{
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for null err ptr. */
CPU_SW_EXCEPTION(;);
}
if (p_seg == DEF_NULL) { /* Chk for null seg ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
#endif
CPU_CRITICAL_ENTER();
p_seg->AddrNext = p_seg->AddrBase;
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
}
#endif
/*
*********************************************************************************************************
* Mem_SegRemSizeGet()
*
* Description : Gets free space of memory segment.
*
* Argument(s) : p_seg Pointer to segment data.
*
* align Alignment in bytes to assume for calculation of free space.
*
* p_seg_info Pointer to structure that will receive further segment info data (used size,
* total size, base address and next allocation address).
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Segment data pointer NULL.
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory alignment.
*
* Return(s) : Memory segment remaining size in bytes, if successful.
* 0, otherwise or if memory segment empty.
*
* Caller(s) : Application,
* Mem_HeapGetSizeRem(),
* Mem_OutputUsage().
*
* Note(s) : None.
*********************************************************************************************************
*/
CPU_SIZE_T Mem_SegRemSizeGet (MEM_SEG *p_seg,
CPU_SIZE_T align,
MEM_SEG_INFO *p_seg_info,
LIB_ERR *p_err)
{
CPU_SIZE_T rem_size;
CPU_SIZE_T total_size;
CPU_SIZE_T used_size;
CPU_ADDR next_addr_align;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for null err ptr. */
CPU_SW_EXCEPTION(0);
}
if (MATH_IS_PWR2(align) != DEF_YES) { /* Chk for invalid align val. */
*p_err = LIB_MEM_ERR_INVALID_MEM_ALIGN;
return (0u);
}
#endif
if (p_seg == DEF_NULL) { /* Dflt to heap in case p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return (0u);
#endif
}
CPU_CRITICAL_ENTER(); /* Calc seg stats. */
next_addr_align = MATH_ROUND_INC_UP_PWR2(p_seg->AddrNext, align);
CPU_CRITICAL_EXIT();
total_size = (p_seg->AddrEnd - p_seg->AddrBase) + 1u;
used_size = p_seg->AddrNext - p_seg->AddrBase;
if (next_addr_align > p_seg->AddrEnd){
next_addr_align = 0u;
rem_size = 0u;
} else {
rem_size = total_size - (next_addr_align - p_seg->AddrBase);
}
if (p_seg_info != DEF_NULL) {
p_seg_info->TotalSize = total_size;
p_seg_info->UsedSize = used_size;
p_seg_info->AddrBase = p_seg->AddrBase;
p_seg_info->AddrNextAlloc = next_addr_align;
}
*p_err = LIB_MEM_ERR_NONE;
return (rem_size);
}
/*
*********************************************************************************************************
* Mem_SegAlloc()
*
* Description : Allocates memory from specified segment. Returned memory block will be aligned on a CPU
* word boundary.
*
* Argument(s) : p_name Pointer to allocated object name. Used for allocations tracking. May be DEF_NULL.
*
* p_seg Pointer to segment from which to allocate memory. Will be allocated from
* general-purpose heap if null.
*
* size Size of memory block to allocate, in bytes.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* ------------------RETURNED BY Mem_SegAllocInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to allocated memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) The memory block returned by this function will be aligned on a word boundary. In
* order to specify a specific alignment value, use either Mem_SegAllocExt() or
* Mem_SegAllocHW().
*********************************************************************************************************
*/
void *Mem_SegAlloc (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
LIB_ERR *p_err)
{
void *p_blk;
if (p_seg == DEF_NULL) { /* Alloc from heap if p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return (DEF_NULL);
#endif
}
p_blk = Mem_SegAllocInternal(p_name,
p_seg,
size,
sizeof(CPU_ALIGN),
LIB_MEM_PADDING_ALIGN_NONE,
DEF_NULL,
p_err);
return (p_blk);
}
/*
*********************************************************************************************************
* Mem_SegAllocExt()
*
* Description : Allocates memory from specified memory segment.
*
* Argument(s) : p_name Pointer to allocated object name. Used for allocations tracking. May be DEF_NULL.
*
* p_seg Pointer to segment from which to allocate memory. Will be allocated from
* general-purpose heap if null.
*
* size Size of memory block to allocate, in bytes.
*
* align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* p_bytes_reqd Pointer to variable that will receive the number of free bytes missing for
* the allocation to succeed. Set to DEF_NULL to skip calculation.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* ------------------RETURNED BY Mem_SegAllocInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to allocated memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : none.
*********************************************************************************************************
*/
void *Mem_SegAllocExt (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
void *p_blk;
if (p_seg == DEF_NULL) { /* Alloc from heap if p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return (DEF_NULL);
#endif
}
p_blk = Mem_SegAllocInternal(p_name,
p_seg,
size,
align,
LIB_MEM_PADDING_ALIGN_NONE,
p_bytes_reqd,
p_err);
return (p_blk);
}
/*
*********************************************************************************************************
* Mem_SegAllocHW()
*
* Description : Allocates memory from specified segment. The returned buffer will be padded in function
* of memory segment's properties.
*
* Argument(s) : p_name Pointer to allocated object name. Used for allocations tracking. May be DEF_NULL.
*
* p_seg Pointer to segment from which to allocate memory. Will be allocated from
* general-purpose heap if null.
*
* size Size of memory block to allocate, in bytes.
*
* align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* p_bytes_reqd Pointer to variable that will receive the number of free bytes missing for
* the allocation to succeed. Set to DEF_NULL to skip calculation.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* ------------------RETURNED BY Mem_SegAllocInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to allocated memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : none.
*********************************************************************************************************
*/
void *Mem_SegAllocHW (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
void *p_blk;
if (p_seg == DEF_NULL) { /* Alloc from heap if p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return (DEF_NULL);
#endif
}
p_blk = Mem_SegAllocInternal(p_name,
p_seg,
size,
align,
p_seg->PaddingAlign,
p_bytes_reqd,
p_err);
return (p_blk);
}
/*
*********************************************************************************************************
* Mem_PoolCreate()
*
* Description : (1) Creates a memory pool :
*
* (a) Create memory pool from heap or dedicated memory
* (b) Allocate memory pool memory blocks
* (c) Configure memory pool
*
*
* Argument(s) : p_pool Pointer to a memory pool structure to create (see Note #1).
*
* p_mem_base Memory pool segment base address :
*
* (a) Null address Memory pool allocated from general-purpose heap.
* (b) Non-null address Memory pool allocated from dedicated memory
* specified by its base address.
*
* mem_size Size of memory pool segment (in bytes).
*
* blk_nbr Number of memory pool blocks to create.
*
* blk_size Size of memory pool blocks to create (in bytes).
*
* blk_align Alignment of memory pool blocks to specific word boundary (in bytes).
*
* p_bytes_reqd Optional pointer to a variable to ... :
*
* (a) Return the number of bytes required to successfully
* allocate the memory pool, if any error(s);
* (b) Return 0, otherwise.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Pointer to memory pool is null.
* LIB_MEM_ERR_INVALID_BLK_ALIGN Invalid block alignment requested.
* LIB_MEM_ERR_INVALID_BLK_NBR Invalid number of blocks specified.
* LIB_MEM_ERR_INVALID_BLK_SIZE Invalid block size specified.
* LIB_MEM_ERR_INVALID_SEG_SIZE Invalid segment size.
* LIB_MEM_ERR_HEAP_EMPTY No more memory available on heap.
*
* ---------------RETURNED BY Mem_SegOverlapChkCritical()----------------
* LIB_MEM_ERR_INVALID_SEG_EXISTS Segment already exists.
* LIB_MEM_ERR_INVALID_SEG_OVERLAP Segment overlaps another existing segment.
*
* -----------------RETURNED BY Mem_SegAllocExtCritical()-----------------
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* ------------------RETURNED BY Mem_SegAllocInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* -----------------------RETURNED BY Mem_PoolClr()-----------------------
* LIB_MEM_ERR_NULL_PTR Argument 'p_pool' passed a NULL pointer.
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_DynPoolCreate() or Mem_DynPoolCreateHW() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
void Mem_PoolCreate (MEM_POOL *p_pool,
void *p_mem_base,
CPU_SIZE_T mem_size,
MEM_POOL_BLK_QTY blk_nbr,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
MEM_SEG *p_seg;
void *p_pool_mem;
CPU_SIZE_T pool_size;
CPU_SIZE_T blk_size_align;
CPU_ADDR pool_addr_end;
MEM_POOL_BLK_QTY blk_ix;
CPU_INT08U *p_blk;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) /* --------------- VALIDATE RTN ERR PTR --------------- */
if (p_err == DEF_NULL) {
CPU_SW_EXCEPTION(;);
}
/* ------------- VALIDATE MEM POOL CREATE ------------- */
if (p_pool == DEF_NULL) {
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
if (p_mem_base != DEF_NULL) {
if (mem_size < 1u) {
*p_err = LIB_MEM_ERR_INVALID_SEG_SIZE;
return;
}
}
if (blk_nbr < 1u) {
*p_err = LIB_MEM_ERR_INVALID_BLK_NBR;
return;
}
if (blk_size < 1u) {
*p_err = LIB_MEM_ERR_INVALID_BLK_SIZE;
return;
}
if (MATH_IS_PWR2(blk_align) != DEF_YES) { /* Chk that req alignment is a pwr of 2. */
*p_err = LIB_MEM_ERR_INVALID_BLK_ALIGN;
return;
}
#endif
Mem_PoolClr(p_pool, p_err); /* Init mem pool. */
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
/* -------- DETERMINE AND/OR ALLOC SEG TO USE --------- */
if (p_mem_base == DEF_NULL) { /* Use heap seg. */
p_seg = &Mem_SegHeap;
} else { /* Use other seg. */
CPU_CRITICAL_ENTER();
p_seg = Mem_SegOverlapChkCritical((CPU_ADDR)p_mem_base,
mem_size,
p_err);
switch (*p_err) {
case LIB_MEM_ERR_INVALID_SEG_EXISTS: /* Seg already exists. */
break;
case LIB_MEM_ERR_NONE: /* Seg must be created. */
p_seg = (MEM_SEG *)Mem_SegAllocExtCritical(&Mem_SegHeap,
sizeof(MEM_SEG),
sizeof(CPU_ALIGN),
LIB_MEM_PADDING_ALIGN_NONE,
p_bytes_reqd,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
CPU_CRITICAL_EXIT();
return;
}
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED) /* Track alloc if req'd. */
Mem_SegAllocTrackCritical("Unknown segment data",
&Mem_SegHeap,
sizeof(MEM_SEG),
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
CPU_CRITICAL_EXIT();
return;
}
#endif
Mem_SegCreateCritical( DEF_NULL,
p_seg,
(CPU_ADDR)p_mem_base,
LIB_MEM_PADDING_ALIGN_NONE,
mem_size);
break;
case LIB_MEM_ERR_INVALID_SEG_OVERLAP:
default:
CPU_CRITICAL_EXIT();
return; /* Prevent 'break NOT reachable' compiler warning. */
}
CPU_CRITICAL_EXIT();
}
/* ---------------- ALLOC MEM FOR POOL ---------------- */
/* Calc blk size with align. */
blk_size_align = MATH_ROUND_INC_UP_PWR2(blk_size, blk_align);
pool_size = blk_size_align * blk_nbr; /* Calc required size for pool. */
/* Alloc mem for pool. */
p_pool_mem = (void *)Mem_SegAllocInternal("Unnamed static pool",
p_seg,
pool_size,
blk_align,
LIB_MEM_PADDING_ALIGN_NONE,
p_bytes_reqd,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
/* ------------ ALLOC MEM FOR FREE BLK TBL ------------ */
p_pool->BlkFreeTbl = (void **)Mem_SegAllocInternal("Unnamed static pool free blk tbl",
&Mem_SegHeap,
blk_nbr * sizeof(void *),
sizeof(CPU_ALIGN),
LIB_MEM_PADDING_ALIGN_NONE,
p_bytes_reqd,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
/* ------------------ INIT BLK LIST ------------------- */
p_blk = (CPU_INT08U *)p_pool_mem;
for (blk_ix = 0; blk_ix < blk_nbr; blk_ix++) {
p_pool->BlkFreeTbl[blk_ix] = p_blk;
p_blk += blk_size_align;
}
/* ------------------ INIT POOL DATA ------------------ */
pool_addr_end = (CPU_ADDR)p_pool_mem + (pool_size - 1u);
p_pool->PoolAddrStart = p_pool_mem;
p_pool->PoolAddrEnd = (void *)pool_addr_end;
p_pool->BlkNbr = blk_nbr;
p_pool->BlkSize = blk_size_align;
p_pool->BlkFreeTblIx = blk_nbr;
}
#endif
/*
*********************************************************************************************************
* Mem_PoolClr()
*
* Description : Clears a memory pool (see Note #1).
*
* Argument(s) : p_pool Pointer to a memory pool structure to clear (see Note #2).
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Argument 'p_pool' passed a NULL pointer.
*
* Return(s) : none.
*
* Caller(s) : Application,
* Mem_PoolCreate().
*
* Note(s) : (1) (a) Mem_PoolClr() ONLY clears a memory pool structure's variables & should ONLY be
* called to initialize a memory pool structure prior to calling Mem_PoolCreate().
*
* (b) Mem_PoolClr() does NOT deallocate memory from the memory pool or deallocate the
* memory pool itself & MUST NOT be called after calling Mem_PoolCreate() since
* this will likely corrupt the memory pool management.
*
* (2) Assumes 'p_pool' points to a valid memory pool (if non-NULL).
*
* (3) This function is DEPRECATED and will be removed in a future version of this product.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
void Mem_PoolClr (MEM_POOL *p_pool,
LIB_ERR *p_err)
{
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) /* -------------- VALIDATE RTN ERR PTR --------------- */
if (p_err == DEF_NULL) {
CPU_SW_EXCEPTION(;);
}
/* -------------- VALIDATE MEM POOL PTR --------------- */
if (p_pool == DEF_NULL) {
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
#endif
p_pool->PoolAddrStart = DEF_NULL;
p_pool->PoolAddrEnd = DEF_NULL;
p_pool->BlkSize = 0u;
p_pool->BlkNbr = 0u;
p_pool->BlkFreeTbl = DEF_NULL;
p_pool->BlkFreeTblIx = 0u;
*p_err = LIB_MEM_ERR_NONE;
}
#endif
/*
*********************************************************************************************************
* Mem_PoolBlkGet()
*
* Description : Gets a memory block from memory pool.
*
* Argument(s) : p_pool Pointer to memory pool to get memory block from.
*
* size Size of requested memory (in bytes).
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_INVALID_BLK_SIZE Invalid memory pool block size requested.
* LIB_MEM_ERR_NULL_PTR Argument 'p_pool' passed a NULL pointer.
* LIB_MEM_ERR_POOL_EMPTY NO memory blocks available in memory pool.
*
* Return(s) : Pointer to memory block, if NO error(s).
*
* Pointer to NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_DynPoolBlkGet() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
void *Mem_PoolBlkGet (MEM_POOL *p_pool,
CPU_SIZE_T size,
LIB_ERR *p_err)
{
CPU_INT08U *p_blk;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) /* -------------- VALIDATE MEM POOL GET --------------- */
if (p_err == DEF_NULL) { /* Validate err ptr. */
CPU_SW_EXCEPTION(DEF_NULL);
}
if (p_pool == DEF_NULL) { /* Validate pool ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return (DEF_NULL);
}
if (size < 1u) { /* Validate req'd size as non-NULL. */
*p_err = LIB_MEM_ERR_INVALID_BLK_SIZE;
return (DEF_NULL);
}
if (size > p_pool->BlkSize) { /* Validate req'd size <= mem pool blk size. */
*p_err = LIB_MEM_ERR_INVALID_BLK_SIZE;
return (DEF_NULL);
}
#else
(void)size; /* Prevent possible 'variable unused' warning. */
#endif
/* -------------- GET MEM BLK FROM POOL --------------- */
p_blk = DEF_NULL;
CPU_CRITICAL_ENTER();
if (p_pool->BlkFreeTblIx > 0u) {
p_pool->BlkFreeTblIx -= 1u;
p_blk = (CPU_INT08U *)p_pool->BlkFreeTbl[p_pool->BlkFreeTblIx];
p_pool->BlkFreeTbl[p_pool->BlkFreeTblIx] = DEF_NULL;
}
CPU_CRITICAL_EXIT();
if (p_blk == DEF_NULL) {
*p_err = LIB_MEM_ERR_POOL_EMPTY;
} else {
*p_err = LIB_MEM_ERR_NONE;
}
return (p_blk);
}
#endif
/*
*********************************************************************************************************
* Mem_PoolBlkFree()
*
* Description : Free a memory block to memory pool.
*
* Argument(s) : p_pool Pointer to memory pool to free memory block.
*
* p_blk Pointer to memory block address to free.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Argument 'p_pool'/'p_blk' passed
* a NULL pointer.
* LIB_MEM_ERR_INVALID_BLK_ADDR Invalid memory block address.
* LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL Memory block address already
* in memory pool.
* LIB_MEM_ERR_POOL_FULL Pool is full.
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_DynPoolBlkFree() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
void Mem_PoolBlkFree (MEM_POOL *p_pool,
void *p_blk,
LIB_ERR *p_err)
{
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
CPU_SIZE_T tbl_ix;
CPU_BOOLEAN addr_valid;
#endif
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) /* -------------- VALIDATE MEM POOL FREE -------------- */
if (p_err == DEF_NULL) {
CPU_SW_EXCEPTION(;);
}
if (p_pool == DEF_NULL) { /* Validate mem ptrs. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
if (p_blk == DEF_NULL) {
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
addr_valid = Mem_PoolBlkIsValidAddr(p_pool, p_blk); /* Validate mem blk as valid pool blk addr. */
if (addr_valid != DEF_OK) {
*p_err = LIB_MEM_ERR_INVALID_BLK_ADDR;
return;
}
CPU_CRITICAL_ENTER(); /* Make sure blk isn't already in free list. */
for (tbl_ix = 0u; tbl_ix < p_pool->BlkNbr; tbl_ix++) {
if (p_pool->BlkFreeTbl[tbl_ix] == p_blk) {
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL;
return;
}
}
#else /* Double-free possibility if not in critical section. */
CPU_CRITICAL_ENTER();
#endif
/* --------------- FREE MEM BLK TO POOL --------------- */
if (p_pool->BlkFreeTblIx >= p_pool->BlkNbr) {
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_POOL_FULL;
return;
}
p_pool->BlkFreeTbl[p_pool->BlkFreeTblIx] = p_blk;
p_pool->BlkFreeTblIx += 1u;
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
}
#endif
/*
*********************************************************************************************************
* Mem_PoolBlkGetNbrAvail()
*
* Description : Get memory pool's remaining number of blocks available to allocate.
*
* Argument(s) : p_pool Pointer to a memory pool structure.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Argument 'p_pool' passed a NULL pointer.
*
* Return(s) : Remaining memory pool blocks, if NO error(s).
*
* 0, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
* Mem_DynPoolBlkNbrAvailGet() should be used instead.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
MEM_POOL_BLK_QTY Mem_PoolBlkGetNbrAvail (MEM_POOL *p_pool,
LIB_ERR *p_err)
{
CPU_SIZE_T nbr_avail;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
/* --------------- VALIDATE RTN ERR PTR --------------- */
if (p_err == DEF_NULL) {
CPU_SW_EXCEPTION(0u);
}
/* ---------------- VALIDATE MEM POOL ----------------- */
if (p_pool == DEF_NULL) { /* Validate mem ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return (0u);
}
#endif
CPU_CRITICAL_ENTER();
nbr_avail = p_pool->BlkFreeTblIx;
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
return (nbr_avail);
}
#endif
/*
*********************************************************************************************************
* Mem_DynPoolCreate()
*
* Description : Creates a dynamic memory pool.
*
* Argument(s) : p_name Pointer to pool name.
*
* p_pool Pointer to pool data.
*
* p_seg Pointer to segment from which to allocate memory. Will be allocated from
* general-purpose heap if null.
*
* blk_size Size of memory block to allocate from pool, in bytes. See Note #1.
*
* blk_align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* blk_qty_init Initial number of elements to be allocated in pool.
*
* blk_qty_max Maximum number of elements that can be allocated from this pool. Set to
* LIB_MEM_BLK_QTY_UNLIMITED if no limit.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* --------------------RETURNED BY Mem_DynPoolCreateInternal()-------------------
* LIB_MEM_ERR_INVALID_BLK_ALIGN Invalid requested block alignment.
* LIB_MEM_ERR_INVALID_BLK_SIZE Invalid requested block size.
* LIB_MEM_ERR_INVALID_BLK_NBR Invalid requested block quantity max.
* LIB_MEM_ERR_NULL_PTR Pool data pointer NULL.
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : None.
*
* Caller(s) : Application.
*
* Note(s) : (1) 'blk_size' must be big enough to fit a pointer since the pointer to the next free
* block is stored in the block itself (only when free/unused).
*********************************************************************************************************
*/
void Mem_DynPoolCreate (const CPU_CHAR *p_name,
MEM_DYN_POOL *p_pool,
MEM_SEG *p_seg,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
CPU_SIZE_T blk_qty_init,
CPU_SIZE_T blk_qty_max,
LIB_ERR *p_err)
{
if (p_seg == DEF_NULL) { /* Alloc from heap if p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
#endif
}
Mem_DynPoolCreateInternal(p_name,
p_pool,
p_seg,
blk_size,
blk_align,
LIB_MEM_PADDING_ALIGN_NONE,
blk_qty_init,
blk_qty_max,
p_err);
}
/*
*********************************************************************************************************
* Mem_DynPoolCreateHW()
*
* Description : Creates a dynamic memory pool. Memory blocks will be padded according to memory segment's
* properties.
*
* Argument(s) : p_name Pointer to pool name.
*
* p_pool Pointer to pool data.
*
* p_seg Pointer to segment from which to allocate memory. Will allocate from
* general-purpose heap if null.
*
* blk_size Size of memory block to allocate from pool, in bytes. See Note #1.
*
* blk_align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* blk_qty_init Initial number of elements to be allocated in pool.
*
* blk_qty_max Maximum number of elements that can be allocated from this pool. Set to
* LIB_MEM_BLK_QTY_UNLIMITED if no limit.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
*
* -------------------RETURNED BY Mem_DynPoolCreateInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : None.
*
* Caller(s) : Application.
*
* Note(s) : (1) 'blk_size' must be big enough to fit a pointer since the pointer to the next free
* block is stored in the block itself (only when free/unused).
*********************************************************************************************************
*/
void Mem_DynPoolCreateHW (const CPU_CHAR *p_name,
MEM_DYN_POOL *p_pool,
MEM_SEG *p_seg,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
CPU_SIZE_T blk_qty_init,
CPU_SIZE_T blk_qty_max,
LIB_ERR *p_err)
{
if (p_seg == DEF_NULL) { /* Alloc from heap if p_seg is null. */
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_seg = &Mem_SegHeap;
#else
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
#endif
}
Mem_DynPoolCreateInternal(p_name,
p_pool,
p_seg,
blk_size,
blk_align,
p_seg->PaddingAlign,
blk_qty_init,
blk_qty_max,
p_err);
}
/*
*********************************************************************************************************
* Mem_DynPoolBlkGet()
*
* Description : Gets a memory block from specified pool, growing it if needed.
*
* Argument(s) : p_pool Pointer to pool data.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR Pool data pointer NULL.
* LIB_MEM_ERR_POOL_EMPTY Pools is empty.
*
* ----------------------RETURNED BY Mem_SegAllocInternal()-----------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Application.
*
* Note(s) : none.
*********************************************************************************************************
*/
void *Mem_DynPoolBlkGet (MEM_DYN_POOL *p_pool,
LIB_ERR *p_err)
{
void *p_blk;
const CPU_CHAR *p_pool_name;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for NULL err ptr. */
CPU_SW_EXCEPTION(DEF_NULL);
}
if (p_pool == DEF_NULL) { /* Chk for NULL pool data ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return (DEF_NULL);
}
#endif
/* Ensure pool is not empty if qty is limited. */
if (p_pool->BlkQtyMax != LIB_MEM_BLK_QTY_UNLIMITED) {
CPU_CRITICAL_ENTER();
if (p_pool->BlkAllocCnt >= p_pool->BlkQtyMax) {
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_POOL_EMPTY;
return (DEF_NULL);
}
p_pool->BlkAllocCnt++;
CPU_CRITICAL_EXIT();
}
/* --------------- ALLOC FROM FREE LIST --------------- */
CPU_CRITICAL_ENTER();
if (p_pool->BlkFreePtr != DEF_NULL) {
p_blk = p_pool->BlkFreePtr;
p_pool->BlkFreePtr = *((void **)p_blk);
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
return (p_blk);
}
CPU_CRITICAL_EXIT();
/* ------------------ ALLOC NEW BLK ------------------- */
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
p_pool_name = p_pool->NamePtr;
#else
p_pool_name = DEF_NULL;
#endif
p_blk = Mem_SegAllocInternal(p_pool_name,
p_pool->PoolSegPtr,
p_pool->BlkSize,
p_pool->BlkAlign,
p_pool->BlkPaddingAlign,
DEF_NULL,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
if (p_pool->BlkQtyMax != LIB_MEM_BLK_QTY_UNLIMITED) {
p_pool->BlkAllocCnt--;
}
return (DEF_NULL);
}
return (p_blk);
}
/*
*********************************************************************************************************
* Mem_DynPoolBlkFree()
*
* Description : Frees memory block, making it available for future use.
*
* Argument(s) : p_pool Pointer to pool data.
*
* p_blk Pointer to first byte of memory block.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR 'p_pool' or 'p_blk' pointer passed is NULL.
* LIB_MEM_ERR_POOL_FULL Pool is full.
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* Note(s) : none.
*********************************************************************************************************
*/
void Mem_DynPoolBlkFree (MEM_DYN_POOL *p_pool,
void *p_blk,
LIB_ERR *p_err)
{
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for NULL err ptr. */
CPU_SW_EXCEPTION(;);
}
if (p_pool == DEF_NULL) { /* Chk for NULL pool data ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
if (p_blk == DEF_NULL) {
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
#endif
if (p_pool->BlkQtyMax != LIB_MEM_BLK_QTY_UNLIMITED) { /* Ensure pool is not full. */
CPU_CRITICAL_ENTER();
if (p_pool->BlkAllocCnt == 0u) {
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_POOL_FULL;
return;
}
p_pool->BlkAllocCnt--;
CPU_CRITICAL_EXIT();
}
CPU_CRITICAL_ENTER();
*((void **)p_blk) = p_pool->BlkFreePtr;
p_pool->BlkFreePtr = p_blk;
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
}
/*
*********************************************************************************************************
* Mem_DynPoolBlkNbrAvailGet()
*
* Description : Gets number of available blocks in dynamic memory pool. This call will fail with a
* dynamic memory pool for which no limit was set at creation.
*
* Argument(s) : p_pool Pointer to pool data.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR 'p_pool' pointer passed is NULL.
* LIB_MEM_ERR_POOL_UNLIMITED Pool has no specified limit.
*
* Return(s) : Number of blocks available in dynamic memory pool, if successful.
*
* 0, if pool is empty or if an error occurred.
*
* Caller(s) : Application.
*
* Note(s) : None.
*********************************************************************************************************
*/
CPU_SIZE_T Mem_DynPoolBlkNbrAvailGet (MEM_DYN_POOL *p_pool,
LIB_ERR *p_err)
{
CPU_SIZE_T blk_nbr_avail;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for NULL err ptr. */
CPU_SW_EXCEPTION(0);
}
if (p_pool == DEF_NULL) { /* Chk for NULL pool data ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return (0u);
}
#endif
if (p_pool->BlkQtyMax != LIB_MEM_BLK_QTY_UNLIMITED) {
CPU_CRITICAL_ENTER();
blk_nbr_avail = p_pool->BlkQtyMax - p_pool->BlkAllocCnt;
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
} else {
blk_nbr_avail = 0u;
*p_err = LIB_MEM_ERR_POOL_UNLIMITED;
}
return (blk_nbr_avail);
}
/*
*********************************************************************************************************
* Mem_OutputUsage()
*
* Description : Outputs memory usage report through 'out_fnct'.
*
* Argument(s) : out_fnct Pointer to output function.
*
* print_details DEF_YES, if the size of each allocation should be printed.
* DEF_NO, otherwise.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_NONE Operation was successful.
* LIB_MEM_ERR_NULL_PTR 'out_fnct' pointer passed is NULL.
*
* ---------------------RETURNED BY Mem_SegRemSizeGet()--------------------
* LIB_MEM_ERR_NULL_PTR Segment data pointer NULL.
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory alignment.
*
* Return(s) : None.
*
* Caller(s) : Application.
*
* Note(s) : none.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
void Mem_OutputUsage(void (*out_fnct) (CPU_CHAR *),
LIB_ERR *p_err)
{
CPU_CHAR str[DEF_INT_32U_NBR_DIG_MAX];
MEM_SEG *p_seg;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for NULL err ptr. */
CPU_SW_EXCEPTION(;);
}
if (out_fnct == DEF_NULL) { /* Chk for NULL out fnct ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
#endif
out_fnct((CPU_CHAR *)"---------------- Memory allocation info ----------------\r\n");
out_fnct((CPU_CHAR *)"| Type | Size | Free size | Name\r\n");
out_fnct((CPU_CHAR *)"|---------|------------|------------|-------------------\r\n");
CPU_CRITICAL_ENTER();
p_seg = Mem_SegHeadPtr;
while (p_seg != DEF_NULL) {
CPU_SIZE_T rem_size;
MEM_SEG_INFO seg_info;
MEM_ALLOC_INFO *p_alloc;
rem_size = Mem_SegRemSizeGet(p_seg, 1u, &seg_info, p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
out_fnct((CPU_CHAR *)"| Section | ");
(void)Str_FmtNbr_Int32U(seg_info.TotalSize,
10u,
DEF_NBR_BASE_DEC,
' ',
DEF_NO,
DEF_YES,
&str[0u]);
out_fnct(str);
out_fnct((CPU_CHAR *)" | ");
(void)Str_FmtNbr_Int32U(rem_size,
10u,
DEF_NBR_BASE_DEC,
' ',
DEF_NO,
DEF_YES,
&str[0u]);
out_fnct(str);
out_fnct((CPU_CHAR *)" | ");
out_fnct((p_seg->NamePtr != DEF_NULL) ? (CPU_CHAR *)p_seg->NamePtr : (CPU_CHAR *)"Unknown");
out_fnct((CPU_CHAR *)"\r\n");
p_alloc = p_seg->AllocInfoHeadPtr;
while (p_alloc != DEF_NULL) {
out_fnct((CPU_CHAR *)"| -> Obj | ");
(void)Str_FmtNbr_Int32U(p_alloc->Size,
10u,
DEF_NBR_BASE_DEC,
' ',
DEF_NO,
DEF_YES,
&str[0u]);
out_fnct(str);
out_fnct((CPU_CHAR *)" | | ");
out_fnct((p_alloc->NamePtr != DEF_NULL) ? (CPU_CHAR *)p_alloc->NamePtr : (CPU_CHAR *)"Unknown");
out_fnct((CPU_CHAR *)"\r\n");
p_alloc = p_alloc->NextPtr;
}
p_seg = p_seg->NextPtr;
}
CPU_CRITICAL_EXIT();
*p_err = LIB_MEM_ERR_NONE;
}
#endif
/*
*********************************************************************************************************
*********************************************************************************************************
* LOCAL FUNCTIONS
*********************************************************************************************************
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* Mem_SegCreateCritical()
*
* Description : Creates a new memory segment to be used for runtime memory allocation or dynamic pools.
*
* Argument(s) : p_name Pointer to segment name.
*
* p_seg Pointer to segment data. Must be allocated by caller.
* ----- Argument validated by caller.
*
* seg_base_addr Segment's first byte address.
*
* padding_align Padding alignment, in bytes, that will be added to any allocated buffer
* from this memory segment. MUST be a power of 2.
* LIB_MEM_PADDING_ALIGN_NONE means no padding.
* ------------- Argument validated by caller.
*
* size Total size of segment, in bytes.
* ---- Argument validated by caller.
*
* Return(s) : Pointer to segment data, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Mem_PoolCreate(),
* Mem_SegCreate().
*
* Note(s) : (1) This function MUST be called within a CRITICAL_SECTION.
*********************************************************************************************************
*/
static void Mem_SegCreateCritical(const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_ADDR seg_base_addr,
CPU_SIZE_T padding_align,
CPU_SIZE_T size)
{
p_seg->AddrBase = seg_base_addr;
p_seg->AddrEnd = (seg_base_addr + (size - 1u));
p_seg->AddrNext = seg_base_addr;
p_seg->NextPtr = Mem_SegHeadPtr;
p_seg->PaddingAlign = padding_align;
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
p_seg->NamePtr = p_name;
p_seg->AllocInfoHeadPtr = DEF_NULL;
#else
(void)p_name;
#endif
Mem_SegHeadPtr = p_seg;
}
/*
*********************************************************************************************************
* Mem_SegOverlapChkCritical()
*
* Description : Checks if existing memory segment exists or overlaps with specified memory area.
*
* Argument(s) : seg_base_addr Address of first byte of memory area.
*
* size Size of memory area, in bytes.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_INVALID_SEG_OVERLAP Segment overlaps another existing segment.
* LIB_MEM_ERR_INVALID_SEG_EXISTS Segment already exists.
*
* Return(s) : Pointer to memory segment that overlaps.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Mem_PoolCreate(),
* Mem_SegCreate().
*
* Note(s) : (1) This function MUST be called within a CRITICAL_SECTION.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
static MEM_SEG *Mem_SegOverlapChkCritical (CPU_ADDR seg_base_addr,
CPU_SIZE_T size,
LIB_ERR *p_err)
{
MEM_SEG *p_seg_chk;
CPU_ADDR seg_new_end;
CPU_ADDR seg_chk_start;
CPU_ADDR seg_chk_end;
seg_new_end = seg_base_addr + (size - 1u);
p_seg_chk = Mem_SegHeadPtr;
while (p_seg_chk != DEF_NULL) {
seg_chk_start = (CPU_ADDR)p_seg_chk->AddrBase;
seg_chk_end = (CPU_ADDR)p_seg_chk->AddrEnd;
if ((seg_base_addr == seg_chk_start) && (seg_new_end == seg_chk_end)) {
*p_err = LIB_MEM_ERR_INVALID_SEG_EXISTS;
return (p_seg_chk);
} else if (((seg_base_addr >= seg_chk_start) && (seg_base_addr <= seg_chk_end)) ||
((seg_base_addr <= seg_chk_start) && (seg_new_end >= seg_chk_start))) {
*p_err = LIB_MEM_ERR_INVALID_SEG_OVERLAP;
return (p_seg_chk);
} else {
/* Empty Else Statement */
}
p_seg_chk = p_seg_chk->NextPtr;
}
*p_err = LIB_MEM_ERR_NONE;
return (DEF_NULL);
}
#endif
/*
*********************************************************************************************************
* Mem_SegAllocInternal()
*
* Description : Allocates memory from specified segment.
*
* Argument(s) : p_name Pointer to allocated object name. Used for allocations tracking. May be DEF_NULL.
*
* p_seg Pointer to segment from which to allocate memory.
* ----- Argument validated by caller.
*
* size Size of memory block to allocate, in bytes.
*
* align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* padding_align Padding alignment, in bytes, that will be added to any allocated buffer from
* this memory segment. MUST be a power of 2. LIB_MEM_PADDING_ALIGN_NONE
* means no padding.
*
* p_bytes_reqd Pointer to variable that will receive the number of free bytes missing for
* the allocation to succeed. Set to DEF_NULL to skip calculation.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
*
* ------------------RETURNED BY Mem_SegAllocExtCritical()------------------
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to allocated memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Mem_DynPoolBlkGet(),
* Mem_DynPoolCreateInternal(),
* Mem_HeapAlloc(),
* Mem_PoolCreate(),
* Mem_SegAlloc(),
* Mem_SegAllocExt(),
* Mem_SegAllocHW().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void *Mem_SegAllocInternal (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T padding_align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
void *p_blk;
CPU_SR_ALLOC();
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for null err ptr. */
CPU_SW_EXCEPTION(DEF_NULL);
}
if (size < 1u) { /* Chk for invalid sized mem req. */
*p_err = LIB_MEM_ERR_INVALID_MEM_SIZE;
return (DEF_NULL);
}
if (MATH_IS_PWR2(align) != DEF_YES) { /* Chk that align is a pwr of 2. */
*p_err = LIB_MEM_ERR_INVALID_MEM_ALIGN;
return (DEF_NULL);
}
#endif
CPU_CRITICAL_ENTER();
p_blk = Mem_SegAllocExtCritical(p_seg,
size,
align,
padding_align,
p_bytes_reqd,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
CPU_CRITICAL_EXIT();
return (DEF_NULL);
}
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED) /* Track alloc if req'd. */
Mem_SegAllocTrackCritical(p_name,
p_seg,
size,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
CPU_CRITICAL_EXIT();
return (DEF_NULL);
}
#else
(void)p_name;
#endif
CPU_CRITICAL_EXIT();
return (p_blk);
}
/*
*********************************************************************************************************
* Mem_SegAllocExtCritical()
*
* Description : Allocates memory from specified segment.
*
* Argument(s) : p_seg Pointer to segment from which to allocate memory.
*
* size Size of memory block to allocate, in bytes.
*
* align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* padding_align Padding alignment, in bytes, that will be added to any allocated buffer from
* this memory segment. MUST be a power of 2. LIB_MEM_PADDING_ALIGN_NONE
* means no padding.
*
* p_bytes_reqd Pointer to variable that will receive the number of free bytes missing for
* the allocation to succeed. Set to DEF_NULL to skip calculation.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : Pointer to allocated memory block, if successful.
*
* DEF_NULL, otherwise.
*
* Caller(s) : Mem_PoolCreate(),
* Mem_SegAllocInternal(),
* Mem_SegAllocTrackCritical().
*
* Note(s) : (1) This function MUST be called within a CRITICAL_SECTION.
*********************************************************************************************************
*/
static void *Mem_SegAllocExtCritical (MEM_SEG *p_seg,
CPU_SIZE_T size,
CPU_SIZE_T align,
CPU_SIZE_T padding_align,
CPU_SIZE_T *p_bytes_reqd,
LIB_ERR *p_err)
{
CPU_ADDR blk_addr;
CPU_ADDR addr_next;
CPU_SIZE_T size_rem_seg;
CPU_SIZE_T size_tot_blk;
CPU_SIZE_T blk_align = DEF_MAX(align, padding_align);
blk_addr = MATH_ROUND_INC_UP_PWR2(p_seg->AddrNext, /* Compute align'ed blk addr. */
blk_align);
addr_next = MATH_ROUND_INC_UP_PWR2(blk_addr + size, /* Compute addr of next alloc. */
padding_align);
size_rem_seg = (p_seg->AddrEnd - p_seg->AddrNext) + 1u;
size_tot_blk = addr_next - p_seg->AddrNext; /* Compute tot blk size including align and padding. */
if (size_rem_seg < size_tot_blk) { /* If seg doesn't have enough space ... */
if (p_bytes_reqd != DEF_NULL) { /* ... calc nbr of req'd bytes. */
*p_bytes_reqd = size_tot_blk - size_rem_seg;
}
*p_err = LIB_MEM_ERR_SEG_OVF;
return (DEF_NULL);
}
p_seg->AddrNext = addr_next;
*p_err = LIB_MEM_ERR_NONE;
return ((void *)blk_addr);
}
/*
*********************************************************************************************************
* Mem_SegAllocTrackCritical()
*
* Description : Tracks segment allocation, adding the 'size' of the allocation under the 'p_name' entry.
*
* Argument(s) : p_name Pointer to the name of the object. This string is not copied and its memory should
* remain accessible at all times.
*
* p_seg Pointer to segment data.
*
* size Allocation size, in bytes.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_HEAP_EMPTY No more memory available on heap
*
* --------------RETURNED BY Mem_SegAllocExtCritical()---------------
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : none.
*
* Caller(s) : Mem_PoolCreate(),
* Mem_SegAllocInternal().
*
* Note(s) : none.
*********************************************************************************************************
*/
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
static void Mem_SegAllocTrackCritical (const CPU_CHAR *p_name,
MEM_SEG *p_seg,
CPU_SIZE_T size,
LIB_ERR *p_err)
{
MEM_ALLOC_INFO *p_alloc;
/* ------- UPDATE ALLOC INFO LIST, IF POSSIBLE -------- */
p_alloc = p_seg->AllocInfoHeadPtr;
while (p_alloc != DEF_NULL) {
if (p_alloc->NamePtr == p_name) {
p_alloc->Size += size;
*p_err = LIB_MEM_ERR_NONE;
return;
}
p_alloc = p_alloc->NextPtr;
}
/* --------- ADD NEW ALLOC INFO ENTRY IN LIST --------- */
p_alloc = (MEM_ALLOC_INFO *)Mem_SegAllocExtCritical(&Mem_SegHeap, /* Alloc new alloc info struct on heap. */
sizeof(MEM_ALLOC_INFO),
sizeof(CPU_ALIGN),
LIB_MEM_PADDING_ALIGN_NONE,
DEF_NULL,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
p_alloc->NamePtr = p_name; /* Populate alloc info. */
p_alloc->Size = size;
p_alloc->NextPtr = p_seg->AllocInfoHeadPtr; /* Prepend new item in list. */
p_seg->AllocInfoHeadPtr = p_alloc;
}
#endif
/*
*********************************************************************************************************
* Mem_DynPoolCreateInternal()
*
* Description : Creates a dynamic memory pool.
*
* Argument(s) : p_name Pointer to pool name.
*
* p_pool Pointer to pool data.
*
* p_seg Pointer to segment from which to allocate memory.
*
* blk_size Size of memory block to allocate from pool, in bytes. See Note #1.
*
* blk_align Required alignment of memory block, in bytes. MUST be a power of 2.
*
* blk_padding_align Block's padding alignment, in bytes, that will be added at the end
* of block's buffer. MUST be a power of 2. LIB_MEM_PADDING_ALIGN_NONE
* means no padding.
*
* blk_qty_init Initial number of elements to be allocated in pool.
*
* blk_qty_max Maximum number of elements that can be allocated from this pool. Set to
* LIB_MEM_BLK_QTY_UNLIMITED if no limit.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* LIB_MEM_ERR_INVALID_BLK_ALIGN Invalid requested block alignment.
* LIB_MEM_ERR_INVALID_BLK_SIZE Invalid requested block size.
* LIB_MEM_ERR_INVALID_BLK_NBR Invalid requested block quantity max.
* LIB_MEM_ERR_NULL_PTR Pool data pointer NULL.
*
* ------------------RETURNED BY Mem_SegAllocInternal()-------------------
* LIB_MEM_ERR_INVALID_MEM_ALIGN Invalid memory block alignment requested.
* LIB_MEM_ERR_INVALID_MEM_SIZE Invalid memory block size specified.
* LIB_MEM_ERR_NULL_PTR Error or segment data pointer NULL.
* LIB_MEM_ERR_SEG_OVF Allocation would overflow memory segment.
*
* Return(s) : None.
*
* Caller(s) : Mem_DynPoolCreate(),
* Mem_DynPoolCreateHW().
*
* Note(s) : (1) 'blk_size' must be big enough to fit a pointer since the pointer to the next free
* block is stored in the block itself (only when free/unused).
*********************************************************************************************************
*/
static void Mem_DynPoolCreateInternal (const CPU_CHAR *p_name,
MEM_DYN_POOL *p_pool,
MEM_SEG *p_seg,
CPU_SIZE_T blk_size,
CPU_SIZE_T blk_align,
CPU_SIZE_T blk_padding_align,
CPU_SIZE_T blk_qty_init,
CPU_SIZE_T blk_qty_max,
LIB_ERR *p_err)
{
CPU_INT08U *p_blks = DEF_NULL;
CPU_SIZE_T blk_size_align;
CPU_SIZE_T blk_align_worst = DEF_MAX(blk_align, blk_padding_align);
#if (LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (p_err == DEF_NULL) { /* Chk for NULL err ptr. */
CPU_SW_EXCEPTION(;);
}
if (p_pool == DEF_NULL) { /* Chk for NULL pool data ptr. */
*p_err = LIB_MEM_ERR_NULL_PTR;
return;
}
if (blk_size < 1u) { /* Chk for inv blk size. */
*p_err = LIB_MEM_ERR_INVALID_BLK_SIZE;
return;
}
if ((blk_qty_max != LIB_MEM_BLK_QTY_UNLIMITED) && /* Chk for invalid blk qty. */
(blk_qty_init > blk_qty_max)) {
*p_err = LIB_MEM_ERR_INVALID_BLK_NBR;
return;
}
if (MATH_IS_PWR2(blk_align) != DEF_YES) { /* Chk for illegal align spec. */
*p_err = LIB_MEM_ERR_INVALID_BLK_ALIGN;
return;
}
#endif
/* Calc blk size with align. */
if (blk_size < sizeof(void *)) { /* If size if smaller than ptr ... */
/* ... inc size to ptr size. */
blk_size_align = MATH_ROUND_INC_UP_PWR2(sizeof(void *), blk_align_worst);
} else {
blk_size_align = MATH_ROUND_INC_UP_PWR2(blk_size, blk_align_worst);
}
if (blk_qty_init != 0u) { /* Alloc init blks. */
CPU_SIZE_T i;
p_blks = (CPU_INT08U *)Mem_SegAllocInternal(p_name,
p_seg,
blk_size_align * blk_qty_init,
DEF_MAX(blk_align, sizeof(void *)),
LIB_MEM_PADDING_ALIGN_NONE,
DEF_NULL,
p_err);
if (*p_err != LIB_MEM_ERR_NONE) {
return;
}
/* ----------------- CREATE POOL DATA ----------------- */
/* Init free list. */
p_pool->BlkFreePtr = (void *)p_blks;
for (i = 0u; i < blk_qty_init - 1u; i++) {
*((void **)p_blks) = p_blks + blk_size_align;
p_blks += blk_size_align;
}
*((void **)p_blks) = DEF_NULL;
} else {
p_pool->BlkFreePtr = DEF_NULL;
}
#if (LIB_MEM_CFG_HEAP_SIZE > 0u)
p_pool->PoolSegPtr = ((p_seg != DEF_NULL) ? p_seg : &Mem_SegHeap);
#else
p_pool->PoolSegPtr = p_seg;
#endif
p_pool->BlkSize = blk_size;
p_pool->BlkAlign = blk_align_worst;
p_pool->BlkPaddingAlign = blk_padding_align;
p_pool->BlkQtyMax = blk_qty_max;
p_pool->BlkAllocCnt = 0u;
#if (LIB_MEM_CFG_DBG_INFO_EN == DEF_ENABLED)
p_pool->NamePtr = p_name;
#endif
*p_err = LIB_MEM_ERR_NONE;
}
/*
*********************************************************************************************************
* Mem_PoolBlkIsValidAddr()
*
* Description : Calculates if a given memory block address is valid for the memory pool.
*
* Argument(s) : p_pool Pointer to memory pool structure to validate memory block address.
* ------ Argument validated by caller.
*
* p_mem Pointer to memory block address to validate.
* ----- Argument validated by caller.
*
* Return(s) : DEF_YES, if valid memory pool block address.
*
* DEF_NO, otherwise.
*
* Caller(s) : Mem_PoolBlkFree().
*
* Note(s) : (1) This function is DEPRECATED and will be removed in a future version of this product.
*********************************************************************************************************
*/
#if ((LIB_MEM_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) && \
(LIB_MEM_CFG_HEAP_SIZE > 0u))
static CPU_BOOLEAN Mem_PoolBlkIsValidAddr (MEM_POOL *p_pool,
void *p_mem)
{
CPU_ADDR pool_offset;
if ((p_mem < p_pool->PoolAddrStart) ||
(p_mem > p_pool->PoolAddrEnd)) {
return (DEF_FALSE);
}
pool_offset = (CPU_ADDR)p_mem - (CPU_ADDR)p_pool->PoolAddrStart;
if (pool_offset % p_pool->BlkSize != 0u) {
return (DEF_FALSE);
} else {
return (DEF_TRUE);
}
}
#endif
View Git Blame Copy Permalink