diff --git a/README.md b/README.md index 36fc75f6..e69f34be 100644 --- a/README.md +++ b/README.md @@ -2611,11 +2611,12 @@ The mempool functions are not thread safe for a given mempool. #### MEMPOOL\_DEF(name, type) -Generate specialized functions named 'name' to alloc & free a 'type' object. +Generate specialized functions & types prefixed by 'name' +to alloc & free a 'type' object. Example: - MEMPOOL_DEF(uint, unsigned int) + MEMPOOL_DEF(mempool_uint, unsigned int) void f(void) { mempool_uint_t m; @@ -2629,27 +2630,27 @@ Example: The following methods are automatically and properly created by the previous macros. In the following methods, name stands for the name given to the macro which is used to identify the type. -##### mempool\_name\_t +##### name\_t The type of a mempool. -##### void mempool\_name\_init(mempool\_name\_t m) +##### void name\_init(name\_t m) Initialize the mempool 'm'. -##### void mempool\_name\_clear(mempool\_name\_t m) +##### void name\_clear(name\_t m) Clear the mempool 'm'. All allocated objects associated to the this mempool which weren't explicitly freed will be deleted too (without calling their clear method). -##### type *mempool\_name\_alloc(mempool\_name\_t m) +##### type *name\_alloc(name\_t m) Create a new object of type 'type' and return a new pointer to the uninitialized object. -##### void mempool\_name\_free(mempool\_name\_t m, type *p) +##### void name\_free(name\_t m, type *p) -Free the object 'p' created by the call to mempool\_name\_alloc. +Free the object 'p' created by the call to name\_alloc. The clear method of the type is not called. diff --git a/m-list.h b/m-list.h index a394b3d5..c9609c82 100644 --- a/m-list.h +++ b/m-list.h @@ -100,7 +100,7 @@ \ /* If MEMPOOL is required, we need to define it */ \ M_IF_METHOD(MEMPOOL, oplist)( \ - MEMPOOL_DEF(M_C(list_,name), struct M_C3(list_, name, _s)) \ + MEMPOOL_DEF(M_C(mempool_list_,name), struct M_C3(list_, name, _s)) \ M_GET_MEMPOOL_LINKAGE oplist M_C3(mempool_list_, name, _t) M_GET_MEMPOOL oplist; \ static inline struct M_C3(list_, name, _s) *M_C3(listi_,name,_new)(void) { \ return M_C3(mempool_list_, name, _alloc)(M_GET_MEMPOOL oplist); \ diff --git a/m-mempool.h b/m-mempool.h index e570f375..5f5ed4e8 100644 --- a/m-mempool.h +++ b/m-mempool.h @@ -43,29 +43,30 @@ // NOTE: Can not use m-list since it may be expanded from LIST_DEF #define MEMPOOL_DEF(name, type) \ - \ - typedef union M_C3(mempool_,name,_union_s) { \ + \ + typedef union M_C(name,_union_s) { \ type t; \ - union M_C3(mempool_,name,_union_s) *next; \ - } M_C3(mempool_,name,_union_t); \ - \ - typedef struct M_C3(mempool_,name,_segment_s) { \ + union M_C(name,_union_s) *next; \ + } M_C(name,_union_t); \ + \ + typedef struct M_C(name,_segment_s) { \ unsigned int count; \ - struct M_C3(mempool_,name,_segment_s) *next; \ - M_C3(mempool_,name,_union_t) tab[MEMPOOLI_MAX_PER_SEGMENT(type)]; \ - } M_C3(mempool_,name,_segment_t); \ - \ + struct M_C(name,_segment_s) *next; \ + M_C(name,_union_t) tab[MEMPOOLI_MAX_PER_SEGMENT(type)]; \ + } M_C(name,_segment_t); \ + \ typedef struct { \ - M_C3(mempool_,name,_union_t) *free_list; \ - M_C3(mempool_,name,_segment_t) *current_segment; \ - } M_C3(mempool_,name,_t)[1]; \ - \ + M_C(name,_union_t) *free_list; \ + M_C(name,_segment_t) *current_segment; \ + } M_C(name,_t)[1]; \ + \ static inline void \ - M_C3(mempool_,name,_init)(M_C3(mempool_,name,_t) mem) \ + M_C(name,_init)(M_C(name,_t) mem) \ { \ mem->free_list = NULL; \ - const size_t size = sizeof (M_C3(mempool_,name,_segment_t)); \ - mem->current_segment = M_ASSIGN_CAST(M_C3(mempool_,name,_segment_t)*, malloc (size)); \ + const size_t size = sizeof (M_C(name,_segment_t)); \ + mem->current_segment = M_ASSIGN_CAST(M_C(name,_segment_t)*, \ + malloc (size)); \ if (mem->current_segment == NULL) { \ M_MEMORY_FULL(size); \ return; \ @@ -74,36 +75,37 @@ mem->current_segment->count = 0; \ MEMPOOLI_CONTRACT(mem, type); \ } \ - \ + \ static inline void \ - M_C3(mempool_,name,_clear)(M_C3(mempool_,name,_t) mem) \ + M_C(name,_clear)(M_C(name,_t) mem) \ { \ MEMPOOLI_CONTRACT(mem, type); \ - M_C3(mempool_,name,_segment_t) *segment = mem->current_segment; \ + M_C(name,_segment_t) *segment = mem->current_segment; \ while (segment != NULL) { \ - M_C3(mempool_,name,_segment_t) *next = segment->next; \ + M_C(name,_segment_t) *next = segment->next; \ free(segment); \ segment = next; \ } \ mem->free_list = NULL; \ mem->current_segment = NULL; \ } \ - \ + \ static inline type * \ - M_C3(mempool_,name,_alloc)(M_C3(mempool_,name,_t) mem) \ + M_C(name,_alloc)(M_C(name,_t) mem) \ { \ MEMPOOLI_CONTRACT(mem, type); \ - M_C3(mempool_,name,_union_t) *ret = mem->free_list; \ + M_C(name,_union_t) *ret = mem->free_list; \ if (ret != NULL) { \ mem->free_list = ret->next; \ return &ret->t; \ } \ - M_C3(mempool_,name,_segment_t) *segment = mem->current_segment; \ + M_C(name,_segment_t) *segment = mem->current_segment; \ assert(segment != NULL); \ unsigned int count = segment->count; \ if (count >= MEMPOOLI_MAX_PER_SEGMENT(type)) { \ - const size_t s = sizeof (M_C3(mempool_,name,_segment_t)); \ - M_C3(mempool_,name,_segment_t) *new_segment = M_ASSIGN_CAST(M_C3(mempool_,name,_segment_t)*, malloc (s)); \ + const size_t s = sizeof (M_C(name,_segment_t)); \ + M_C(name,_segment_t) *new_segment = M_ASSIGN_CAST(M_C(name,_segment_t)*, \ + malloc (s)); \ if (new_segment == NULL) { \ M_MEMORY_FULL(s); \ return NULL; \ @@ -119,14 +121,14 @@ MEMPOOLI_CONTRACT(mem, type); \ return &ret->t; \ } \ - \ + \ static inline void \ - M_C3(mempool_,name,_free)(M_C3(mempool_,name,_t) mem, type *ptr) \ + M_C(name,_free)(M_C(name,_t) mem, type *ptr) \ { \ MEMPOOLI_CONTRACT(mem, type); \ /* NOTE: Unsafe cast: suppose that the given pointer \ was allocated by the previous alloc function. */ \ - M_C3(mempool_,name,_union_t) *ret = (M_C3(mempool_,name,_union_t) *)(uintptr_t)ptr; \ + M_C(name,_union_t) *ret = (M_C(name,_union_t) *)(uintptr_t)ptr; \ ret->next = mem->free_list; \ mem->free_list = ret; \ MEMPOOLI_CONTRACT(mem, type); \ diff --git a/m-rbtree.h b/m-rbtree.h index c9f16910..c37cc23f 100644 --- a/m-rbtree.h +++ b/m-rbtree.h @@ -142,7 +142,7 @@ typedef enum { typedef type M_C3(rbtree_type_, name, _t); \ \ M_IF_METHOD(MEMPOOL, oplist)( \ - MEMPOOL_DEF(M_C(rbtree_,name), node_t) \ + MEMPOOL_DEF(M_C(mempool_rbtree_,name), node_t) \ M_GET_MEMPOOL_LINKAGE oplist M_C3(mempool_rbtree_, name, _t) M_GET_MEMPOOL oplist; \ static inline node_t *M_C3(rbtreei_,name,_new)(void) { \ return M_C3(mempool_rbtree_, name, _alloc)(M_GET_MEMPOOL oplist); \ diff --git a/tests/test-mmempool.c b/tests/test-mmempool.c index e79f90e6..e9640970 100644 --- a/tests/test-mmempool.c +++ b/tests/test-mmempool.c @@ -28,7 +28,7 @@ #include "coverage.h" START_COVERAGE -MEMPOOL_DEF(uint, unsigned int) +MEMPOOL_DEF(mempool_uint, unsigned int) END_COVERAGE static void test(void)