From e030118750e3f2446a12ca2711b35cd56046be09 Mon Sep 17 00:00:00 2001 From: goldsimon Date: Tue, 26 Jul 2016 15:01:39 +0200 Subject: [PATCH] moved MEM_LIBC_MALLOC code from mem.h to mem.c: - it's not worth littering mem.h just to save some bytes to prevent the additional call; - MEM_STATS now also work when MEM_LIBC_MALLOC is enabled --- src/core/mem.c | 107 ++++++++++++++++++++++++++++++++++++++--- src/core/memp.c | 7 ++- src/include/lwip/mem.h | 38 +++------------ 3 files changed, 111 insertions(+), 41 deletions(-) diff --git a/src/core/mem.c b/src/core/mem.c index b9991eb9..070d103a 100644 --- a/src/core/mem.c +++ b/src/core/mem.c @@ -54,9 +54,6 @@ */ #include "lwip/opt.h" - -#if !MEM_LIBC_MALLOC /* don't build if not configured for use in lwipopts.h */ - #include "lwip/def.h" #include "lwip/mem.h" #include "lwip/sys.h" @@ -65,7 +62,91 @@ #include -#if MEM_USE_POOLS +#if MEM_LIBC_MALLOC || MEM_USE_POOLS +/** mem_init is not used when using pools instead of a heap or using + * C library malloc(). + */ +void +mem_init(void) +{ +} + +/** mem_trim is not used when using pools instead of a heap or using + * C library malloc(): we can't free part of a pool element and the stack + * support mem_trim() to return a different pointer + */ +void* +mem_trim(void *mem, mem_size_t size) +{ + LWIP_UNUSED_ARG(size); + return mem; +} +#endif /* MEM_LIBC_MALLOC || MEM_USE_POOLS */ + +#if MEM_LIBC_MALLOC +/* lwIP heap implemented using C library malloc() */ + +/* in case C library malloc() needs extra protection, + * allow these defines to be overridden. + */ +#ifndef mem_clib_free +#define mem_clib_free free +#endif +#ifndef mem_clib_malloc +#define mem_clib_malloc malloc +#endif +#ifndef mem_clib_calloc +#define mem_clib_calloc calloc +#endif + +#if LWIP_STATS && MEM_STATS +#define MEM_LIBC_STATSHELPER_SIZE LWIP_MEM_ALIGN_SIZE(sizeof(mem_size_t)) +#else +#define MEM_LIBC_STATSHELPER_SIZE 0 +#endif + +/** + * Allocate a block of memory with a minimum of 'size' bytes. + * + * @param size is the minimum size of the requested block in bytes. + * @return pointer to allocated memory or NULL if no free memory was found. + * + * Note that the returned value must always be aligned (as defined by MEM_ALIGNMENT). + */ +void * +mem_malloc(mem_size_t size) +{ + void* ret = mem_clib_malloc(size + MEM_LIBC_STATSHELPER_SIZE); + if (ret == NULL) { + MEM_STATS_INC(err); + } else { + LWIP_ASSERT("malloc() must return aligned memory", LWIP_MEM_ALIGN(ret) == ret); +#if LWIP_STATS && MEM_STATS + *(mem_size_t*)ret = size; + ret = (u8_t*)ret + MEM_LIBC_STATSHELPER_SIZE; + MEM_STATS_INC_USED(used, size); +#endif + } + return ret; +} + +/** Put memory back on the heap + * + * @param rmem is the pointer as returned by a previous call to mem_malloc() + */ +void +mem_free(void *rmem) +{ + LWIP_ASSERT("rmem != NULL", (rmem != NULL)); + LWIP_ASSERT("rmem == MEM_ALIGN(rmem)", (rmem == LWIP_MEM_ALIGN(rmem))); +#if LWIP_STATS && MEM_STATS + rmem = (u8_t*)rmem - MEM_LIBC_STATSHELPER_SIZE; + MEM_STATS_DEC_USED(used, *(mem_size_t*)rmem); +#endif + mem_clib_free(rmem); +} + +#elif MEM_USE_POOLS /* lwIP heap implemented with different sized pools */ @@ -96,6 +177,7 @@ again: } if (poolnr > MEMP_POOL_LAST) { LWIP_ASSERT("mem_malloc(): no pool is that big!", 0); + MEM_STATS_INC(err); return NULL; } element = (struct memp_malloc_helper*)memp_malloc(poolnr); @@ -109,6 +191,7 @@ again: goto again; } #endif /* MEM_USE_POOLS_TRY_BIGGER_POOL */ + MEM_STATS_INC(err); return NULL; } @@ -509,7 +592,6 @@ mem_trim(void *rmem, mem_size_t newsize) } /** - * Adam's mem_malloc() plus solution for bug #17922 * Allocate a block of memory with a minimum of 'size' bytes. * * @param size is the minimum size of the requested block in bytes. @@ -660,6 +742,15 @@ mem_malloc_adjust_lfree: } #endif /* MEM_USE_POOLS */ + +#if MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) +void * +mem_calloc(mem_size_t count, mem_size_t size) +{ + return mem_clib_calloc(count, size); +} + +#else /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ /** * Contiguously allocates enough space for count objects that are size bytes * of memory each and returns a pointer to the allocated memory. @@ -670,7 +761,8 @@ mem_malloc_adjust_lfree: * @param size size of the objects to allocate * @return pointer to allocated memory / NULL pointer if there is an error */ -void *mem_calloc(mem_size_t count, mem_size_t size) +void * +mem_calloc(mem_size_t count, mem_size_t size) { void *p; @@ -682,5 +774,4 @@ void *mem_calloc(mem_size_t count, mem_size_t size) } return p; } - -#endif /* !MEM_LIBC_MALLOC */ +#endif /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ diff --git a/src/core/memp.c b/src/core/memp.c index 8a60fadb..97187d15 100644 --- a/src/core/memp.c +++ b/src/core/memp.c @@ -228,7 +228,9 @@ memp_overflow_init(const struct memp_desc *desc) void memp_init_pool(const struct memp_desc *desc) { -#if !MEMP_MEM_MALLOC +#if MEMP_MEM_MALLOC + LWIP_UNUSED_ARG(desc); +#else int i; struct memp *memp; @@ -277,7 +279,7 @@ memp_init(void) for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) { memp_init_pool(memp_pools[i]); -#if LWIP_STATS +#if LWIP_STATS && MEMP_STATS lwip_stats.memp[i] = memp_pools[i]->stats; #endif } @@ -436,6 +438,7 @@ do_memp_free_pool(const struct memp_desc* desc, void *mem) #endif #if MEMP_MEM_MALLOC + LWIP_UNUSED_ARG(desc); SYS_ARCH_UNPROTECT(old_level); mem_free(memp); #else /* MEMP_MEM_MALLOC */ diff --git a/src/include/lwip/mem.h b/src/include/lwip/mem.h index 791c5b94..e4f6a64d 100644 --- a/src/include/lwip/mem.h +++ b/src/include/lwip/mem.h @@ -46,30 +46,15 @@ extern "C" { #if MEM_LIBC_MALLOC #include /* for size_t */ - typedef size_t mem_size_t; #define MEM_SIZE_F SZT_F -/* aliases for C library malloc() */ -#define mem_init() -/* in case C library malloc() needs extra protection, - * allow these defines to be overridden. - */ -#ifndef mem_free -#define mem_free free -#endif -#ifndef mem_malloc -#define mem_malloc malloc -#endif -#ifndef mem_calloc -#define mem_calloc calloc -#endif -/* Since there is no C library allocation function to shrink memory without - moving it, define this to nothing. */ -#ifndef mem_trim -#define mem_trim(mem, size) (mem) -#endif -#else /* MEM_LIBC_MALLOC */ +#elif MEM_USE_POOLS + +typedef u16_t mem_size_t; +#define MEM_SIZE_F U16_F + +#else /* MEM_SIZE would have to be aligned, but using 64000 here instead of * 65535 leaves some room for alignment... @@ -81,22 +66,13 @@ typedef u32_t mem_size_t; typedef u16_t mem_size_t; #define MEM_SIZE_F U16_F #endif /* MEM_SIZE > 64000 */ +#endif -#if MEM_USE_POOLS -/** mem_init is not used when using pools instead of a heap */ -#define mem_init() -/** mem_trim is not used when using pools instead of a heap: - we can't free part of a pool element and don't want to copy the rest */ -#define mem_trim(mem, size) (mem) -#else /* MEM_USE_POOLS */ -/* lwIP alternative malloc */ void mem_init(void); void *mem_trim(void *mem, mem_size_t size); -#endif /* MEM_USE_POOLS */ void *mem_malloc(mem_size_t size); void *mem_calloc(mem_size_t count, mem_size_t size); void mem_free(void *mem); -#endif /* MEM_LIBC_MALLOC */ #ifdef __cplusplus }