From 93a1be616d42720b486f31ee6023ad44176fab91 Mon Sep 17 00:00:00 2001 From: Patrick Pelissier Date: Mon, 21 Apr 2025 09:58:44 +0200 Subject: [PATCH] Rename parameter pool to context --- README.md | 2 +- doc/API.txt | 2 +- example/ex11-use-pool.c | 17 ++++++--- m-array.h | 12 +++---- m-bitset.h | 4 +-- m-bptree.h | 14 ++++---- m-bstring.h | 2 +- m-buffer.h | 44 +++++++++++------------ m-core.h | 77 ++++++++++++++++++++--------------------- m-deque.h | 12 +++---- m-dict.h | 6 ++-- m-list.h | 2 +- m-prioqueue.h | 2 +- m-queue.h | 10 +++--- m-rbtree.h | 2 +- m-serial-bin.h | 26 +++++++------- m-serial-json.h | 32 ++++++++--------- m-shared-ptr.h | 60 ++++++++++++++++---------------- m-snapshot.h | 10 +++--- m-string.h | 8 ++--- m-tree.h | 4 +-- m-tuple.h | 28 +++++++-------- m-variant.h | 12 +++---- m-worker.h | 18 +++++----- 24 files changed, 206 insertions(+), 200 deletions(-) diff --git a/README.md b/README.md index 165aefc3..c3db0303 100644 --- a/README.md +++ b/README.md @@ -9178,7 +9178,7 @@ _________________ ### M-MEMPOOL > [!NOTE] -> This header is obsolete: `M_USE_POOL` should be used instead to pass custom memory context to containers. +> This header is obsolete: `M_USE_CONTEXT` should be used instead to pass custom memory context to containers. This header is for generating specialized and optimized memory pools: it will generate specialized functions to allocate and free only one kind of an object. diff --git a/doc/API.txt b/doc/API.txt index b7dc9a3e..4fe94bd1 100644 --- a/doc/API.txt +++ b/doc/API.txt @@ -98,7 +98,7 @@ V0.8.0 : * The prototypes of REALLOC / FREE operators are incompatible: * m-buffer: Remove buffer blocking policy BUFFER_BLOCKING (default policy is now forced) and thread safe (_push / _pop returns now void) * m-buffer push / pop no longer return a bool (it was undocumented) * Remove MEMPOOL support from list & R/B tree - * m-mempool: Header is obsolete (and no longer useful at all as lists & RB Tree no longer can use it. To remove?). Use new M_USE_POOL interface to pass local pool context. + * m-mempool: Header is obsolete (and no longer useful at all as lists & RB Tree no longer can use it. To remove?). Use new M_USE_CONTEXT interface to pass local pool context. * M*LIB becomes stricter for INIT_MOVE: Emulation layer using CLEAR+INIT_SET when missing INIT_MOVE operator has been removed: either default INIT_MOVE operator (operator '=') is working, or a method is provided for INIT_MOVE or it is disabled. If it is an array of size 1, you can use M_COPY_A1_DEFAULT as a default method. (It's because supporting emulation layer with new memory context parameter was complicated) diff --git a/example/ex11-use-pool.c b/example/ex11-use-pool.c index 023ebdd4..3fa52735 100644 --- a/example/ex11-use-pool.c +++ b/example/ex11-use-pool.c @@ -1,7 +1,9 @@ #include +// Define the memory context. typedef int *context_t; +// Define the realloc / free that accepts the memory context. static void *my_realloc(void *ptr, size_t old, size_t new, size_t base, context_t context) { (void) context; @@ -17,13 +19,18 @@ static void my_free(void *ptr, size_t old, size_t base, context_t context) free(ptr); } -# define M_USE_POOL context_t -# define M_MEMORY_REALLOC(type, ptr, o, n) my_realloc(ptr, o, n, sizeof (type), m_pool) -# define M_MEMORY_FREE(type, ptr, o) my_free(ptr, o, sizeof (*ptr), m_pool) +// Request M*LIB to generate functions accepting a memory context parameter that will be passed to the memory functions +# define M_USE_CONTEXT context_t -# define M_MEMORY_ALLOC(type) my_realloc(NULL, 0, 1, sizeof (type), m_pool) -# define M_MEMORY_DEL(ptr) my_free(ptr, 1, sizeof (*ptr), m_pool) +// Overloaded memory functions to use the custom ones. +// m_context is the name of the memory context parameter +# define M_MEMORY_REALLOC(type, ptr, o, n) my_realloc(ptr, o, n, sizeof (type), m_context) +# define M_MEMORY_FREE(type, ptr, o) my_free(ptr, o, sizeof (*ptr), m_context) +# define M_MEMORY_ALLOC(type) my_realloc(NULL, 0, 1, sizeof (type), m_context) +# define M_MEMORY_DEL(ptr) my_free(ptr, 1, sizeof (*ptr), m_context) + +// Now we can include M*LIB functions. #include "m-string.h" #include "m-bitset.h" #include "m-bstring.h" diff --git a/m-array.h b/m-array.h index e723add9..4c2bd6e6 100644 --- a/m-array.h +++ b/m-array.h @@ -80,7 +80,7 @@ /* OPLIST definition of a dynamic array */ /* FIXME: Do we want to export some methods as they are slow and are not fit to be used for building other methods (like _it_remove)? */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_ARRA4_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)) \ ,M_IF_METHOD2(INIT_SET,SET, oplist)(INIT_SET(M_F(name, _init_set)),) \ @@ -270,7 +270,7 @@ M_P(void, name, _reset, array_t v) \ { \ M_ARRA4_CONTRACT(v); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ for(size_t i = 0; i < v->size; i++) \ M_CALL_CLEAR(oplist, v->ptr[i]); \ v->size = 0; \ @@ -351,7 +351,7 @@ M_P(void, name, _set_at, array_t v, size_t i, type const x) \ { \ M_ARRA4_CONTRACT(v); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT(v->size > 0 && v->ptr != NULL); \ M_ASSERT_INDEX(i, v->size); \ M_CALL_SET(oplist, v->ptr[i], x); \ @@ -543,7 +543,7 @@ M_P(void, name, _pop_back, type *dest, array_t v) \ { \ M_ARRA4_CONTRACT(v); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT (v->ptr != NULL); \ M_ASSERT_INDEX(0, v->size); \ v->size--; \ @@ -602,7 +602,7 @@ M_P(void, name, _pop_at, type *dest, array_t v, size_t i) \ { \ M_ARRA4_CONTRACT(v); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT (v->size > 0 && v->ptr != NULL); \ M_ASSERT_INDEX(i, v->size); \ if (dest) \ @@ -661,7 +661,7 @@ M_P(void, name, _remove_v, array_t v, size_t i, size_t j) \ { \ M_ARRA4_CONTRACT(v); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT(i < j && v->ptr != NULL); \ M_ASSERT_INDEX(i, v->size); \ M_ASSERT_INDEX(j, v->size+1); \ diff --git a/m-bitset.h b/m-bitset.h index dd81ea97..482d67d7 100644 --- a/m-bitset.h +++ b/m-bitset.h @@ -834,7 +834,7 @@ m_bitset_popcount(const m_bitset_t set) } /* Oplist for a bitset */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_BITSET_OPLIST \ (INIT(m_bitset_init) \ ,INIT_SET(m_bitset_init_set) \ @@ -907,7 +907,7 @@ m_bitset_popcount(const m_bitset_t set) #endif /* Register the OPLIST as a global one */ -#ifdef M_USE_POOL +#ifdef M_USE_CONTEXT #define M_OPL_m_bitset_t() M_BITSET_POOL_OPLIST #else #define M_OPL_m_bitset_t() M_BITSET_OPLIST diff --git a/m-bptree.h b/m-bptree.h index 93ea8fb7..8bf07115 100644 --- a/m-bptree.h +++ b/m-bptree.h @@ -156,7 +156,7 @@ ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, oplist))) /* OPLIST definition of a b+tree (global tree) */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_BPTR33_KEY_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ @@ -239,7 +239,7 @@ ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, key_oplist, value_oplist))) /* Final definition of the oplist (associative array) */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_BPTR33_OPLIST2_P4(name, key_oplist, value_oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ @@ -706,7 +706,7 @@ M_IF(isMap)( M_DEFERRED_COMMA value_t const value,) ) \ { \ M_ASSERT (M_F(name, _is_leaf)(n)); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ int i, num = M_F(name, _get_num)(n); \ M_ASSERT (num <= N); \ /* Search for the key in the node n (a leaf) for insertion */ \ @@ -737,7 +737,7 @@ M_P(int, name, _i_search_and_insert_in_node, node_t n, node_t l, key_t key) \ { \ M_ASSERT (!M_F(name, _is_leaf)(n)); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ int i, num = M_F(name, _get_num)(n); \ M_ASSERT (num <= N); \ /* Search for the key in the node n (not a leaf) for insertion */ \ @@ -869,7 +869,7 @@ M_P(int, name, _i_search_and_remove_in_leaf, node_t n, key_t const key) \ { \ M_ASSERT(M_F(name, _is_leaf)(n)); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ const int num = M_F(name, _get_num)(n); \ for(int i = 0; i < num; i++) { \ const int cmp = M_CALL_CMP(key_oplist, key, n->key[i]); \ @@ -890,7 +890,7 @@ { \ M_ASSERT (parent != NULL && !M_F(name, _is_leaf)(parent)); \ M_ASSERT (0 <= k && k < M_F(name, _get_num)(parent)); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ node_t left = parent->kind.node[k]; \ node_t right = parent->kind.node[k+1]; \ M_ASSERT (left != NULL && right != NULL); \ @@ -926,7 +926,7 @@ { \ M_ASSERT (parent != NULL && !M_F(name, _is_leaf)(parent)); \ M_ASSERT (0 <= k && k < M_F(name, _get_num)(parent)); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ node_t left = parent->kind.node[k]; \ node_t right = parent->kind.node[k+1]; \ M_ASSERT (left != NULL && right != NULL); \ diff --git a/m-bstring.h b/m-bstring.h index 0e13630a..60f30059 100644 --- a/m-bstring.h +++ b/m-bstring.h @@ -534,7 +534,7 @@ M_P(m_serial_return_code_t, m_bstring, _in_serial, m_bstring_t v, m_serial_read_ } /* Define the OPLIST of a BYTE STRING */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_BSTRING_OPLIST \ (INIT(m_bstring_init),INIT_SET(m_bstring_init_set), SET(m_bstring_set), \ INIT_MOVE(m_bstring_init_move), MOVE(m_bstring_move), \ diff --git a/m-buffer.h b/m-buffer.h index 7486286a..7398fec8 100644 --- a/m-buffer.h +++ b/m-buffer.h @@ -221,7 +221,7 @@ typedef enum { M_N(void, name, _init, buffer_t v, size_t size) \ { \ M_ASSERT(size <= UINT_MAX); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_BUFF3R_IF_CTE_SIZE(m_size)(M_ASSERT(size == m_size), v->capacity = size); \ v->idx_prod = v->idx_cons = v->overwrite = 0; \ atomic_init (&v->number[0], 0U); \ @@ -256,7 +256,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _i_clear_obj, buffer_t v) \ { \ M_BUFF3R_CONTRACT(v,m_size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_INIT_POP_MOVE)) { \ for(size_t i = 0; i < M_BUFF3R_SIZE(m_size); i++) { \ M_CALL_CLEAR(oplist, v->data[i].x); \ @@ -280,7 +280,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _clear, buffer_t v) \ { \ M_BUFF3R_CONTRACT(v,m_size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name,_i_clear_obj)(v); \ M_BUFF3R_IF_CTE_SIZE(m_size)( , \ M_CALL_FREE(oplist, M_F(name, _el_ct), v->data, M_BUFF3R_SIZE(m_size)); \ @@ -296,7 +296,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _reset, buffer_t v) \ { \ M_BUFF3R_CONTRACT(v,m_size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ m_mutex_lock(v->mutexPush); \ m_mutex_lock(v->mutexPop); \ M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size); \ @@ -314,7 +314,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ \ M_N(void, name, _init_set, buffer_t dest, const buffer_t src) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ /* un-const 'src', so that we can lock it (semantically it is const) */ \ M_F(name, _uptr_ct) vu; \ vu.cptr = src; \ @@ -354,7 +354,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ \ M_N(void, name, _set, buffer_t dest, const buffer_t src) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ /* un-const 'src', so that we can lock it (semantically it is const) */ \ M_F(name, _uptr_ct) vu; \ vu.cptr = src; \ @@ -449,7 +449,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(bool, name, _push_blocking, buffer_t v, type const data, bool blocking) \ { \ M_BUFF3R_CONTRACT(v,m_size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ /* Producer Mutex lock (mutex lock performs an acquire memory barrier) */ \ m_mutex_lock(v->mutexPush); \ while (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_OVERWRITE) \ @@ -523,7 +523,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ { \ M_BUFF3R_CONTRACT(v,m_size); \ M_ASSERT (data != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ /* consumer lock (mutex lock performs an acquire memory barrier) */ \ m_mutex_lock(v->mutexPop); \ while (M_F(name, _empty_p)(v)) { \ @@ -714,7 +714,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(bool, name, _push, buffer_t table, type const x) \ { \ M_QU3UE_MPMC_CONTRACT(table); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int idx = atomic_load_explicit(&table->ProdIdx, \ memory_order_relaxed); \ const unsigned int i = idx & (table->size -1); \ @@ -749,7 +749,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ { \ M_QU3UE_MPMC_CONTRACT(table); \ M_ASSERT (ptr != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int iC = atomic_load_explicit(&table->ConsoIdx, \ memory_order_relaxed); \ const unsigned int i = (iC & (table->size -1)); \ @@ -779,7 +779,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_ASSERT (buffer != NULL); \ M_ASSERT( M_POWEROF2_P(size) && 0 < size && size <= UINT_MAX); \ M_ASSERT(((policy) & (M_BUFFER_STACK|M_BUFFER_PUSH_OVERWRITE)) == 0); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ atomic_init(&buffer->ProdIdx, (unsigned int) size); \ atomic_init(&buffer->ConsoIdx, (unsigned int) size); \ buffer->size = (unsigned int) size; \ @@ -799,7 +799,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _clear, buffer_t buffer) \ { \ M_QU3UE_MPMC_CONTRACT(buffer); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_INIT_POP_MOVE)) { \ for(unsigned int j = 0; j < buffer->size; j++) { \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \ @@ -939,7 +939,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(bool, name, _push, buffer_t table, type const x) \ { \ M_QU3UE_SPSC_CONTRACT(table); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ memory_order_relaxed); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ @@ -960,7 +960,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(bool, name, _push_move, buffer_t table, type *x) \ { \ M_QU3UE_SPSC_CONTRACT(table); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ memory_order_relaxed); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ @@ -982,7 +982,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ { \ M_QU3UE_SPSC_CONTRACT(table); \ M_ASSERT (ptr != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ memory_order_relaxed); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ @@ -1005,7 +1005,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_QU3UE_SPSC_CONTRACT(table); \ M_ASSERT (x != NULL); \ M_ASSERT (n <= table->size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ memory_order_relaxed); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ @@ -1031,7 +1031,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_QU3UE_SPSC_CONTRACT(table); \ M_ASSERT (ptr != NULL); \ M_ASSERT (n <= table->size); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ memory_order_relaxed); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ @@ -1055,7 +1055,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _push_force, buffer_t table, type const x) \ { \ M_QU3UE_SPSC_CONTRACT(table); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ unsigned int r = atomic_load_explicit(&table->consoIdx, \ memory_order_relaxed); \ unsigned int w = atomic_load_explicit(&table->prodIdx, \ @@ -1119,7 +1119,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_ASSERT (buffer != NULL); \ M_ASSERT( M_POWEROF2_P(size) && 0 < size && size <= UINT_MAX); \ M_ASSERT(((policy) & (M_BUFFER_STACK|M_BUFFER_PUSH_OVERWRITE)) == 0); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ atomic_init(&buffer->prodIdx, (unsigned int) size); \ atomic_init(&buffer->consoIdx, (unsigned int) size); \ buffer->size = (unsigned int) size; \ @@ -1138,7 +1138,7 @@ M_N(void, name, _init, buffer_t v, size_t size) \ M_N(void, name, _clear, buffer_t buffer) \ { \ M_QU3UE_SPSC_CONTRACT(buffer); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_INIT_POP_MOVE)) { \ for(unsigned int j = 0; j < buffer->size; j++) { \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \ @@ -1193,12 +1193,12 @@ M_N(void, name, _init, buffer_t v, size_t size) \ ,GET_SIZE(M_F(name, _size)) \ ) -/* Same as M_EMPLACE_QUEUE_GENE but use M_GLOBAL_POOL */ +/* Same as M_EMPLACE_QUEUE_GENE but use M_GLOBAL_CONTEXT */ #define M_BUFF3R_EMPLACE_QUEUE_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \ M_N(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \ { \ M_GET_TYPE oplist data; \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type); \ M_F(name, _push)(v, data); \ M_CALL_CLEAR(oplist, data); \ diff --git a/m-core.h b/m-core.h index 5000112c..b07757b1 100644 --- a/m-core.h +++ b/m-core.h @@ -385,7 +385,7 @@ M_BEGIN_PROTECTED_CODE * It returns NULL in case of memory allocation failure. * void M_MEMORY_FREE(type, ptr, o): Free the object associated to the array of type 'type' at base 'ptr' of size 'o'. * By default, old size do nothing. - * Can use local optional named parameter "m_pool" which is defined by the called of the macro if M_USE_POOL is defined. + * Can use local optional named parameter "m_context" which is defined by the called of the macro if M_USE_CONTEXT is defined. */ #ifndef M_MEMORY_REALLOC #ifdef __cplusplus @@ -412,59 +412,60 @@ M_BEGIN_PROTECTED_CODE #endif +// Default global memory context is to consider the global context as '0' if it is not defined. +#ifndef M_USE_GLOBAL_CONTEXT +#define M_USE_GLOBAL_CONTEXT(varname) M_USE_CONTEXT varname = { 0 } +#endif + /* In order to support local context for memory functions, the prototypes and usages of some functions are modified - * so that they can accept a first argument 'm_pool' which is the memory context parameter. + * so that they can accept a first argument 'm_context' which is the memory context parameter. * * For some functions, there is no meaning of a local memory context parameter: * for all data shared between threads, only a global memory context has any meaning. * For such cases, the memory context parameter is globally requested to the user through M_USE_GLOBAL_POOL or set to 0. * - * This is controlled through M_USE_POOL parameter that define the type of the memory context parameter + * This is controlled through M_USE_CONTEXT parameter that define the type of the memory context parameter * to be used globally for all M*LIB. There is no possibility to support only some containers and not others. * * Several macros are defined **globally** to support such features and being internally used by M*LIB containers. * They expand to nothing if the memory context parameter is not requested: - * * M_P_EXPAND: expand to the first parameter 'm_pool' of type M_USE_POOL for a function that may use memory context. + * * M_P_EXPAND: expand to the first parameter 'm_context' of type M_USE_CONTEXT for a function that may use memory context. * * M_P_EXPAND_void: same but assume that there is no argument in the initial function. - * * M_R_EXPAND: expand to the first parameter 'm_pool' (followed by a comma) + * * M_R_EXPAND: expand to the first parameter 'm_context' (followed by a comma) * * M_R_EXPAND_void: same but assume that there is no argument - * * M_R: add the parameter m_pool to the function call if needed, - * * M_P: define the prototype of a function that may have the parameter m_pool. - * * M_N: define the prototype of a function that don't need the parameter m_pool. - * * M_ASSERT_POOL: avoid warning of unused m_pool argument - * * M_GLOBAL_POOL: define m_pool to zero, meaning it is a global memory context. + * * M_R: add the parameter m_context to the function call if needed, + * * M_P: define the prototype of a function that may have the parameter m_context. + * * M_N: define the prototype of a function that don't need the parameter m_context. + * * M_UNUSED_CONTEXT: avoid warning of unused m_context argument + * * M_GLOBAL_CONTEXT: define m_context to zero, meaning it is a global memory context. */ -#ifndef M_USE_POOL -// Memory pool parameter not used for memory function. Stub it with 0 as it won't be used (global definition). +#ifndef M_USE_CONTEXT +// Memory context parameter not used for memory function. # define M_P_EXPAND # define M_P_EXPAND_void void # define M_R_EXPAND # define M_R_EXPAND_void # define M_R -# define M_ASSERT_POOL() -# define M_GLOBAL_POOL() +# define M_UNUSED_CONTEXT() +# define M_GLOBAL_CONTEXT() #else -// Default global value is to set to 0 the global pool. -#ifndef M_USE_GLOBAL_POOL -#define M_USE_GLOBAL_POOL(x) M_USE_POOL x = { 0 } -#endif -// Memory pool parameter is used for function using memory. (local definition to the function). +// Memory context parameter is used for function using memory. (local definition to the function). // Expand to a prototype to a function that may not trigger exception -# define M_P_EXPAND M_USE_POOL m_pool, -# define M_P_EXPAND_void M_USE_POOL m_pool -# define M_R_EXPAND m_pool , -# define M_R_EXPAND_void m_pool -# define M_R(...) (m_pool, __VA_ARGS__) -# define M_ASSERT_POOL() (void) m_pool -# define M_GLOBAL_POOL() M_USE_GLOBAL_POOL(m_pool); (void) m_pool +# define M_P_EXPAND M_USE_CONTEXT m_context, +# define M_P_EXPAND_void M_USE_CONTEXT m_context +# define M_R_EXPAND m_context , +# define M_R_EXPAND_void m_context +# define M_R(...) (m_context, __VA_ARGS__) +# define M_UNUSED_CONTEXT() (void) m_context +# define M_GLOBAL_CONTEXT() M_USE_GLOBAL_CONTEXT(m_context); (void) m_context #endif // M_P: Expand to a prototype of a function that may trigger exception / accept memory context // M_N: Expand to a prototype of a function that may not trigger exception or accept memory context -// If not user M_F, no overloaded M_INLINE and no M_P_EXPAND, -// simplify definition of M_P/M_N to provide faster compile time. +// If not user defined M_F or memory context, no overloaded M_INLINE, +// simplify the definition of M_P/M_N to provide faster compile time. // (faster build: 0.54s instead of 0.80s in extreme expanding) -#if !defined(M_USE_POOL) && !defined(M_F) && !defined(M_USE_FINE_GRAINED_LINKAGE) && !defined(M_USE_DEF) && !defined(M_USE_DECL) +#if !defined(M_USE_CONTEXT) && !defined(M_F) && !defined(M_USE_FINE_GRAINED_LINKAGE) && !defined(M_USE_DEF) && !defined(M_USE_DECL) # define M_P(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__) # define M_N(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__) #else @@ -472,8 +473,6 @@ M_BEGIN_PROTECTED_CODE # define M_N(rettype, name, suffix, ...) M_INLINE rettype M_F(name, suffix)(__VA_ARGS__) #endif -// TODO: 'pool' seems not the right term. Rename 'pool' into 'localmem' ? 'arena'? memcontext? context? -// Rename to M_USE_MEMORY_CONTEXT? M_USE_MEMCONTEXT /************************************************************/ /********************* ERROR handling **********************/ @@ -3730,14 +3729,14 @@ M_INLINE size_t m_core_cstr_hash(const char str[]) #define M_OPLAPI_5(method, oplist, x, ...) , x = M_DELAY3(method)(oplist, __VA_ARGS__) #define M_OPLAPI_6(method, oplist, x, ...) , M_DELAY3(method)(&x, &__VA_ARGS__) #define M_OPLAPI_7(method, oplist, x, ...) , M_DELAY3(method)(oplist, &x, &__VA_ARGS__) -#define M_OPLAPI_0P(method, oplist, ...) , M_DELAY3(method)(m_pool, __VA_ARGS__) -#define M_OPLAPI_1P(method, oplist, ...) , M_DELAY3(method)(oplist, m_pool, __VA_ARGS__) -#define M_OPLAPI_2P(method, oplist, ...) , M_DELAY3(method)(m_pool, & __VA_ARGS__) -#define M_OPLAPI_3P(method, oplist, ...) , M_DELAY3(method)(oplist, m_pool, &__VA_ARGS__) -#define M_OPLAPI_4P(method, oplist, x, ...) , x = M_DELAY3(method)(m_pool, __VA_ARGS__) -#define M_OPLAPI_5P(method, oplist, x, ...) , x = M_DELAY3(method)(oplist, m_pool, __VA_ARGS__) -#define M_OPLAPI_6P(method, oplist, x, ...) , M_DELAY3(method)(m_pool, &x, &__VA_ARGS__) -#define M_OPLAPI_7P(method, oplist, x, ...) , M_DELAY3(method)(oplist, m_pool, &x, &__VA_ARGS__) +#define M_OPLAPI_0P(method, oplist, ...) , M_DELAY3(method)(m_context, __VA_ARGS__) +#define M_OPLAPI_1P(method, oplist, ...) , M_DELAY3(method)(oplist, m_context, __VA_ARGS__) +#define M_OPLAPI_2P(method, oplist, ...) , M_DELAY3(method)(m_context, & __VA_ARGS__) +#define M_OPLAPI_3P(method, oplist, ...) , M_DELAY3(method)(oplist, m_context, &__VA_ARGS__) +#define M_OPLAPI_4P(method, oplist, x, ...) , x = M_DELAY3(method)(m_context, __VA_ARGS__) +#define M_OPLAPI_5P(method, oplist, x, ...) , x = M_DELAY3(method)(oplist, m_context, __VA_ARGS__) +#define M_OPLAPI_6P(method, oplist, x, ...) , M_DELAY3(method)(m_context, &x, &__VA_ARGS__) +#define M_OPLAPI_7P(method, oplist, x, ...) , M_DELAY3(method)(oplist, m_context, &x, &__VA_ARGS__) /* API transformation support for indirection */ #define M_OPLAPI_INDIRECT_0 M_OPLAPI_ERROR #define M_OPLAPI_INDIRECT_API_0(...) M_OPLAPI_0 diff --git a/m-deque.h b/m-deque.h index b1d41390..9cbf9ad0 100644 --- a/m-deque.h +++ b/m-deque.h @@ -103,7 +103,7 @@ M_EMPLACE_QUEUE_DEF(name, deque_t, _emplace_front, oplist, M_D3QUE_EMPLACE_FRONT_DEF) // OPLIST for the node deletion -#ifdef M_USE_POOL +#ifdef M_USE_CONTEXT #define M_D3QU3_NODE_DEL_OPLIST(name) (DEL(API_0P(M_F(name, _node_list_i_del)))) #else #define M_D3QU3_NODE_DEL_OPLIST(name) (DEL(M_F(name, _node_list_i_del))) @@ -222,7 +222,7 @@ M_P(void, name, _reset, deque_t d) \ { \ M_D3QU3_CONTRACT(d); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ node_t *min_node = NULL; \ for(node_t *n = d->front->node; \ n != NULL ; \ @@ -365,7 +365,7 @@ { \ M_D3QU3_CONTRACT(d); \ M_ASSERT(d->count > 0); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ node_t *n = d->back->node; \ size_t index = d->back->index; \ index --; \ @@ -407,7 +407,7 @@ { \ M_D3QU3_CONTRACT(d); \ M_ASSERT(d->count > 0); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ node_t *n = d->front->node; \ size_t index = d->front->index; \ if (ptr != NULL) \ @@ -825,7 +825,7 @@ M_P(void, name, _set_at, deque_t d, size_t key, type const x) \ { \ M_D3QU3_CONTRACT(d); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT_INDEX (key, d->count); \ type *p = M_F(name, _get)(d, key); \ M_CALL_SET(oplist, *p, x); \ @@ -1057,7 +1057,7 @@ ((M_LIB_ERROR(ARGUMENT_OF_DEQUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist))) /* OPLIST definition of a deque */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_D3QU3_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)) \ ,INIT_SET(M_F(name, _init_set)) \ diff --git a/m-dict.h b/m-dict.h index f946991d..50ecae78 100644 --- a/m-dict.h +++ b/m-dict.h @@ -1253,7 +1253,7 @@ M_ARRAY_DEF(m_array_index, m_indexhash_t, M_POD_OPLIST) /* Define the oplist of a dictionary NOTE: IT_REF is not exported so that the contained appears as not modifiable by algorithm.*/ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_D1CT_OPLIST_P4(name, key_oplist, value_oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ @@ -1349,7 +1349,7 @@ M_ARRAY_DEF(m_array_index, m_indexhash_t, M_POD_OPLIST) /* Define the oplist of a set Note: IT_REF is not exported so that the contained appears as not modifiable */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_D1CT_SET_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ @@ -2078,7 +2078,7 @@ enum m_d1ct_oa_element_e { M_P(void, name, _bulk_get, unsigned n, value_type val[M_VLA(n)], dict_t dict, key_type const key[M_VLA(n)], value_type def) \ { \ M_D1CT_OA_CONTRACT (dict); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ size_t h[M_USE_MAX_PREFETCH]; \ M_F(name, _pair_ct) *data = dict->data; \ const size_t mask = dict->mask; \ diff --git a/m-list.h b/m-list.h index 11c8e818..250c1d66 100644 --- a/m-list.h +++ b/m-list.h @@ -101,7 +101,7 @@ ((M_LIB_ERROR(ARGUMENT_OF_LIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist))) /* OPLIST definition of a list and list_dual_push */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_L1ST_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ diff --git a/m-prioqueue.h b/m-prioqueue.h index 77979745..75b635a1 100644 --- a/m-prioqueue.h +++ b/m-prioqueue.h @@ -71,7 +71,7 @@ ((M_LIB_ERROR(ARGUMENT_OF_PRIOQUEUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist))) /* Define oplist of a priority queue */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_PR1OQUEUE_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)) \ ,INIT_SET(M_F(name, _init_set)) \ diff --git a/m-queue.h b/m-queue.h index 182a2f81..1353b285 100644 --- a/m-queue.h +++ b/m-queue.h @@ -168,7 +168,7 @@ M_P(void, name, _init, queue_t v, size_t size) \ { \ M_ASSERT(size <= UINT_MAX); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_QUEU3_IF_CTE_SIZE(m_size)(M_ASSERT(size == m_size), v->capacity = (unsigned) size); \ v->idx_prod = v->idx_cons = v->number = 0; \ \ @@ -194,7 +194,7 @@ M_QUEU3_IF_CTE_SIZE(m_size)( \ M_P(void, name, _i_clear_obj, queue_t v) \ { \ M_QUEU3_CONTRACT(v,m_size); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ for(size_t i = 0; i < M_QUEU3_SIZE(v, m_size); i++) { \ M_CALL_CLEAR(oplist, v->data[i]); \ } \ @@ -205,7 +205,7 @@ M_QUEU3_IF_CTE_SIZE(m_size)( \ M_P(void, name, _clear, queue_t v) \ { \ M_QUEU3_CONTRACT(v,m_size); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_F(name,_i_clear_obj)M_R(v); \ M_QUEU3_IF_CTE_SIZE(m_size)( , \ M_CALL_FREE(oplist, type, v->data, M_QUEU3_SIZE(v, m_size)); \ @@ -264,7 +264,7 @@ M_QUEU3_IF_CTE_SIZE(m_size)( \ M_P(bool, name, _push, queue_t v, type const data) \ { \ M_QUEU3_CONTRACT(v,m_size); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ if (M_F(name, _full_p)(v)) \ return false; \ \ @@ -284,7 +284,7 @@ M_QUEU3_IF_CTE_SIZE(m_size)( \ { \ M_QUEU3_CONTRACT(v,m_size); \ M_ASSERT (data != NULL); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ if (M_F(name, _empty_p)(v)) \ return false; \ \ diff --git a/m-rbtree.h b/m-rbtree.h index e8b6edef..99299972 100644 --- a/m-rbtree.h +++ b/m-rbtree.h @@ -71,7 +71,7 @@ /* OPLIST definition of a rbtree NOTE: IT_REF is not exported so that the container appears as not modifiable by algorithm.*/ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_RBTR33_OPLIST_P3(name, oplist) \ (INIT(M_F(name, _init)), \ INIT_SET(M_F(name, _init_set)), \ diff --git a/m-serial-bin.h b/m-serial-bin.h index ad8b242d..fb6ef26c 100644 --- a/m-serial-bin.h +++ b/m-serial-bin.h @@ -113,7 +113,7 @@ m_ser1al_bin_read_size(FILE *f, size_t *size) Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_boolean, m_serial_write_t serial, const bool data) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); FILE *f = (FILE *)serial->data[0].p; size_t n = fwrite (M_ASSIGN_CAST(const void*, &data), sizeof (bool), 1, f); return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail(); @@ -123,7 +123,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_boolean, m_serial_write_t seria Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_integer, m_serial_write_t serial,const long long data, const size_t size_of_type) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); size_t n; FILE *f = (FILE *)serial->data[0].p; @@ -148,7 +148,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_integer, m_serial_write_t seria Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_float, m_serial_write_t serial, const long double data, const size_t size_of_type) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); size_t n; FILE *f = (FILE *)serial->data[0].p; @@ -170,7 +170,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_float, m_serial_write_t serial, Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_string, m_serial_write_t serial, const char data[], size_t length) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); M_ASSERT_SLOW(length == strlen(data) ); FILE *f = (FILE *)serial->data[0].p; M_ASSERT(f != NULL && data != NULL); @@ -190,7 +190,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_string, m_serial_write_t serial Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; //Unused if (number_of_elements == (size_t)-1) return M_SERIAL_FAIL_RETRY; FILE *f = (FILE *)serial->data[0].p; @@ -202,7 +202,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_start, m_serial_local_t l Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_next, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // Unused (void) serial; // Unused return M_SERIAL_OK_CONTINUE; @@ -212,7 +212,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_next, m_serial_local_t lo Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // Unused (void) serial; // Unused return M_SERIAL_OK_CONTINUE; @@ -222,7 +222,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_end, m_serial_local_t loc Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_map_value, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) serial; return M_SERIAL_OK_CONTINUE; @@ -234,7 +234,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_map_value, m_serial_local_t loc Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_start, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) serial; return M_SERIAL_OK_CONTINUE; @@ -244,7 +244,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_start, m_serial_local_t l Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_id, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) serial; (void) field_name; @@ -257,7 +257,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_id, m_serial_local_t loca Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) serial; return M_SERIAL_OK_DONE; @@ -270,7 +270,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_end, m_serial_local_t loc Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_variant_start, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) field_name; (void) max; (void) local; @@ -283,7 +283,7 @@ M_P(m_serial_return_code_t, m_ser1al_bin, _write_variant_start, m_serial_local_t Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_bin, _write_variant_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) serial; return M_SERIAL_OK_DONE; diff --git a/m-serial-json.h b/m-serial-json.h index 557b9e82..f773ba21 100644 --- a/m-serial-json.h +++ b/m-serial-json.h @@ -38,7 +38,7 @@ M_BEGIN_PROTECTED_CODE Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_boolean, m_serial_write_t serial, const bool data) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "%s", data ? "true" : "false"); return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail(); @@ -48,7 +48,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_boolean, m_serial_write_t seri Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_integer, m_serial_write_t serial,const long long data, const size_t size_of_type) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) size_of_type; // Ignored FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "%lld", data); @@ -59,7 +59,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_integer, m_serial_write_t seri Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_float, m_serial_write_t serial, const long double data, const size_t size_of_type) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) size_of_type; // Ignored FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "%Lf", data); @@ -70,7 +70,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_float, m_serial_write_t serial Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_string, m_serial_write_t serial, const char data[], size_t length) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); M_ASSERT(length == (m_str1ng_size_t) length); M_ASSERT_SLOW(length == strlen(data) ); FILE *f = (FILE *)serial->data[0].p; @@ -94,7 +94,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_string, m_serial_write_t seria Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) number_of_elements; // Ignored FILE *f = (FILE *)serial->data[0].p; @@ -106,7 +106,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_start, m_serial_local_t Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_next, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, ","); @@ -117,7 +117,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_next, m_serial_local_t l Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "]"); @@ -132,7 +132,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_array_end, m_serial_local_t lo Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) number_of_elements; // Ignored FILE *f = (FILE *)serial->data[0].p; @@ -144,7 +144,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_start, m_serial_local_t lo Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_value, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, ":"); @@ -155,7 +155,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_value, m_serial_local_t lo Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_next, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, ","); @@ -166,7 +166,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_next, m_serial_local_t loc Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "}"); @@ -179,7 +179,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_map_end, m_serial_local_t loca Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_start, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "{"); @@ -190,7 +190,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_start, m_serial_local_t Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_id, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) max; // Ignored FILE *f = (FILE *)serial->data[0].p; @@ -202,7 +202,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_id, m_serial_local_t loc Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "}"); @@ -216,7 +216,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_end, m_serial_local_t lo Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_variant_start, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used (void) max; // argument not used FILE *f = (FILE *)serial->data[0].p; @@ -235,7 +235,7 @@ M_P(m_serial_return_code_t, m_ser1al_json, _write_variant_start, m_serial_local_ Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */ M_P(m_serial_return_code_t, m_ser1al_json, _write_variant_end, m_serial_local_t local, m_serial_write_t serial) { - M_ASSERT_POOL(); + M_UNUSED_CONTEXT(); (void) local; // argument not used FILE *f = (FILE *)serial->data[0].p; int n = fprintf(f, "}"); diff --git a/m-shared-ptr.h b/m-shared-ptr.h index ff80a35c..562d60ea 100644 --- a/m-shared-ptr.h +++ b/m-shared-ptr.h @@ -613,7 +613,7 @@ extern shared_t *function_name(M_EMPLACE_LIST_TYPE_VAR_ALTER(a, exp_emplace_type M_IF_METHOD(INIT, oplist)( \ fattr shared_t *M_F(name, _new)(void) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ shared_t *out = M_CALL_NEW(oplist, shared_t); \ if (M_UNLIKELY_NOMEM( out == NULL)) { \ M_MEMORY_FULL(shared_t, 1); \ @@ -629,7 +629,7 @@ M_IF_METHOD(INIT_SET, oplist)( \ fattr shared_t *M_F(name, _clone)(const shared_t *src) \ { \ M_ASSERT(src != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ shared_t *out = M_CALL_NEW(oplist, shared_t); \ if (M_UNLIKELY_NOMEM( out == NULL)) { \ M_MEMORY_FULL(shared_t, 1); \ @@ -646,7 +646,7 @@ M_IF_METHOD(INIT_SET, oplist)( \ fattr shared_t *M_F(name, _new_from)(type const src); ) \ fattr shared_t *M_F(name, _new_from)(type const src) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ shared_t *out = M_CALL_NEW(oplist, shared_t); \ if (M_UNLIKELY_NOMEM( out == NULL)) { \ M_MEMORY_FULL(shared_t, 1); \ @@ -663,7 +663,7 @@ M_IF_METHOD(SET, oplist)( \ { \ M_ASSERT(out != NULL); \ M_ASSERT(src != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (M_UNLIKELY (out == src)) return; \ M_F(name, _write_read_lock)(out, src); \ M_ON_EXCEPTION( M_F(name, _write_read_unlock)(out, src) ) \ @@ -682,7 +682,7 @@ fattr shared_t *M_F(name, _acquire)(shared_t *out) \ \ fattr void M_F(name, _release)(shared_t *out) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (out != NULL && M_C3(m_shar3d_, name, _dec_owner)(out)) { \ M_CALL_CLEAR(oplist, out->data); \ M_F(name, _clear_lock)(out); \ @@ -706,7 +706,7 @@ M_EMPLACE_QUEUE_DEF( (name, fattr), shared_t, M_F(name, _make), oplist, M_SHAR3D #define M_SHAR3D_PTR_DEF_BASIC_MAKE(name_attr, shared_t, function_name, oplist, init_func, exp_emplace_type) \ M_PAIR_2 name_attr shared_t *function_name(M_EMPLACE_LIST_TYPE_VAR_ALTER(a, exp_emplace_type)) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ shared_t *out = M_CALL_NEW(oplist, shared_t); \ if (M_UNLIKELY_NOMEM( out == NULL)) { \ M_MEMORY_FULL(shared_t, 1); \ @@ -753,7 +753,7 @@ M_IF_METHOD(RESET, oplist)( \ fattr void M_F(name, _reset)(shared_t *out) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ /* RESET cannot throw exception */ \ M_CALL_RESET(oplist, out->data); \ @@ -866,7 +866,7 @@ M_IF_METHOD(ADD, oplist)( \ fattr void M_F(name, _add)(shared_t *out, const shared_t *src1, const shared_t *src2) \ { \ M_ASSERT(out != NULL && src1 != NULL && src2 != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_read2_lock)(out, src1, src2); \ M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) ) \ M_CALL_ADD(oplist, out->data, src1->data, src2->data); \ @@ -878,7 +878,7 @@ M_IF_METHOD(SUB, oplist)( \ fattr void M_F(name, _sub)(shared_t *out, const shared_t *src1, const shared_t *src2) \ { \ M_ASSERT(out != NULL && src1 != NULL && src2 != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_read2_lock)(out, src1, src2); \ M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) ) \ M_CALL_SUB(oplist, out->data, src1->data, src2->data); \ @@ -890,7 +890,7 @@ M_IF_METHOD(MUL, oplist)( \ fattr void M_F(name, _mul)(shared_t *out, const shared_t *src1, const shared_t *src2) \ { \ M_ASSERT(out != NULL && src1 != NULL && src2 != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_read2_lock)(out, src1, src2); \ M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) ) \ M_CALL_MUL(oplist, out->data, src1->data, src2->data); \ @@ -902,7 +902,7 @@ M_IF_METHOD(DIV, oplist)( \ fattr void M_F(name, _div)(shared_t *out, const shared_t *src1, const shared_t *src2) \ { \ M_ASSERT(out != NULL && src1 != NULL && src2 != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_read2_lock)(out, src1, src2); \ M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) ) \ M_CALL_DIV(oplist, out->data, src1->data, src2->data); \ @@ -914,7 +914,7 @@ M_IF_METHOD(SPLICE, oplist)( \ fattr void M_F(name, _splice)(shared_t *out, shared_t *src) \ { \ M_ASSERT(out != NULL && src != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (out < src) { \ M_F(name, _write_lock)(out); \ M_F(name, _write_lock)(src); \ @@ -944,7 +944,7 @@ M_IF_METHOD(GET_KEY, oplist)( \ { \ M_ASSERT (out != NULL); \ M_ASSERT (value != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _read_lock)(out); \ /* No exception */ \ value_type *p = M_CALL_GET_KEY(oplist, out->data, key); \ @@ -961,7 +961,7 @@ M_IF_METHOD(SAFE_GET_KEY, oplist)( \ { \ M_ASSERT (out != NULL); \ M_ASSERT (value != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) { \ value_type *p = M_CALL_SAFE_GET_KEY(oplist, out->data, key); \ @@ -977,7 +977,7 @@ M_IF_METHOD(SET_KEY, oplist)( \ fattr void M_F(name, _set_at)(shared_t *out, key_type const key, value_type const value) \ { \ M_ASSERT (out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) \ M_CALL_SET_KEY(oplist, out->data, key, value); \ @@ -990,7 +990,7 @@ M_IF_METHOD(ERASE_KEY, oplist)( \ fattr bool M_F(name, _erase)(shared_t *out, key_type const key) \ { \ M_ASSERT (out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ /* No exception */ \ bool r = M_CALL_ERASE_KEY(oplist, out->data, key); \ @@ -1021,7 +1021,7 @@ M_IF_METHOD(PUSH, oplist)( \ fattr void M_F(name, _push)(shared_t *out, sub_type const value) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ while (true) { \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1038,7 +1038,7 @@ M_IF_METHOD(PUSH, oplist)( \ fattr bool M_F(name, _try_push)(shared_t *out, sub_type const value) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ bool ret = false; \ M_F(name, _write_lock)(out); \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1055,7 +1055,7 @@ M_IF_METHOD(PUSH_MOVE, oplist)( \ fattr void M_F(name, _push_move)(shared_t *out, sub_type *value) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ while (true) { \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1072,7 +1072,7 @@ M_IF_METHOD(PUSH_MOVE, oplist)( \ fattr bool M_F(name, _try_push_move)(shared_t *out, sub_type *value) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ bool ret = false; \ M_F(name, _write_lock)(out); \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1094,7 +1094,7 @@ M_IF_METHOD(PUSH_MOVE, oplist)( \ fattr void function_name(shared_t *out M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type)) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ while (true) { \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1117,7 +1117,7 @@ fattr void function_name(shared_t *out M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_ty fattr bool function_name(shared_t *out M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type)) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ bool ret = false; \ M_F(name, _write_lock)(out); \ if (M_CALL_FULL_P(oplist, out->data) == false) { \ @@ -1146,7 +1146,7 @@ M_IF_METHOD(POP, oplist)( \ fattr void M_F(name, _pop)(sub_type *value, shared_t *out) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ while (true) { \ if (M_CALL_EMPTY_P(oplist, out->data) == false) { \ @@ -1163,7 +1163,7 @@ M_IF_METHOD(POP, oplist)( \ fattr bool M_F(name, _try_pop)(sub_type *value, shared_t *out) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ bool ret = false; \ M_F(name, _write_lock)(out); \ if (M_CALL_EMPTY_P(oplist, out->data) == false) { \ @@ -1180,7 +1180,7 @@ M_IF_METHOD(POP_MOVE, oplist)( \ fattr void M_F(name, _pop_move)(sub_type *value, shared_t *out) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ while (true) { \ if (M_CALL_EMPTY_P(oplist, out->data) == false) { \ @@ -1197,7 +1197,7 @@ M_IF_METHOD(POP_MOVE, oplist)( \ fattr bool M_F(name, _try_pop_move)(sub_type *value, shared_t *out) \ { \ M_ASSERT(out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ bool ret = false; \ M_F(name, _write_lock)(out); \ if (M_CALL_EMPTY_P(oplist, out->data) == false) { \ @@ -1326,7 +1326,7 @@ M_IF_METHOD(IN_STR, oplist)( \ fattr bool M_F(name, _in_str)(shared_t *out, FILE *file) \ { \ M_ASSERT (out != NULL && file != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ m_volatile bool r = false; \ M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) \ @@ -1341,7 +1341,7 @@ M_IF_METHOD(GET_STR, oplist)( \ fattr void M_F(name, _get_str)(m_string_t str, const shared_t *out, bool append) \ { \ M_ASSERT (out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _read_lock)(out); \ M_ON_EXCEPTION( M_F(name, _read_unlock)(out) ) \ M_CALL_GET_STR(oplist, str, out->data, append); \ @@ -1352,7 +1352,7 @@ M_IF_METHOD(PARSE_STR, oplist)( \ fattr bool M_F(name, _parse_str)(shared_t *out, const char str[], const char **endp) \ { \ M_ASSERT (out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ m_volatile bool r = false; \ M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) \ @@ -1379,7 +1379,7 @@ M_IF_METHOD(IN_SERIAL, oplist)( \ fattr m_serial_return_code_t M_F(name, _in_serial)(shared_t *out, m_serial_read_t serial) \ { \ M_ASSERT (out != NULL); \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_F(name, _write_lock)(out); \ m_volatile m_serial_return_code_t r = M_SERIAL_FAIL; \ M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) \ diff --git a/m-snapshot.h b/m-snapshot.h index 4b82afe3..37d834d9 100644 --- a/m-snapshot.h +++ b/m-snapshot.h @@ -201,7 +201,7 @@ M_BEGIN_PROTECTED_CODE M_P(void, name, _init, snapshot_t snap) \ { \ M_ASSERT(snap != NULL); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) { \ M_CALL_INIT(oplist, snap->data[i].x); \ } \ @@ -212,7 +212,7 @@ M_BEGIN_PROTECTED_CODE M_P(void, name, _clear, snapshot_t snap) \ { \ M_SNAPSH0T_SPSC_CONTRACT(snap); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) { \ M_CALL_CLEAR(oplist, snap->data[i].x); \ } \ @@ -222,7 +222,7 @@ M_BEGIN_PROTECTED_CODE M_P(void, name, _init_set, snapshot_t snap, snapshot_t org) \ { \ M_SNAPSH0T_SPSC_CONTRACT(org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT(snap != NULL && snap != org); \ for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) { \ M_CALL_INIT_SET(oplist, snap->data[i].x, org->data[i].x); \ @@ -236,7 +236,7 @@ M_BEGIN_PROTECTED_CODE { \ M_SNAPSH0T_SPSC_CONTRACT(snap); \ M_SNAPSH0T_SPSC_CONTRACT(org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) { \ M_CALL_SET(oplist, snap->data[i].x, org->data[i].x); \ } \ @@ -264,7 +264,7 @@ M_BEGIN_PROTECTED_CODE { \ M_SNAPSH0T_SPSC_CONTRACT(snap); \ M_SNAPSH0T_SPSC_CONTRACT(org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT(snap != org); \ for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) { \ M_CALL_MOVE(oplist, snap->data[i].x, org->data[i].x); \ diff --git a/m-string.h b/m-string.h index 036fa803..8139550f 100644 --- a/m-string.h +++ b/m-string.h @@ -2106,7 +2106,7 @@ namespace m_lib { m_lib::m_aligned_string(s).string #endif -#ifdef M_USE_POOL +#ifdef M_USE_CONTEXT /* Initialize and set a string to the given formatted value. */ #define m_string_init_printf(pool, v, ...) \ (m_string_printf ( pool, m_str1ng_init_ref(v), __VA_ARGS__) ) @@ -2138,7 +2138,7 @@ namespace m_lib { #endif /* Define the OPLIST of a STRING */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_STRING_OPLIST \ (INIT(m_string_init),INIT_SET(m_string_init_set), SET(m_string_set), \ INIT_WITH(M_STR1NG_INIT_WITH), \ @@ -2263,7 +2263,7 @@ namespace m_lib { )(a,b,c) /* Init & Set the string a to the string (or C string) b (constructor) */ -#ifdef M_USE_POOL +#ifdef M_USE_CONTEXT #define m_string_init_set(p, a,b) \ _Generic((b)+0, \ char*: m_string_init_set_cstr, \ @@ -2275,7 +2275,7 @@ namespace m_lib { #endif /* Set the string a to the string (or C string) b */ -#ifdef M_USE_POOL +#ifdef M_USE_CONTEXT #define m_string_set(p, a,b) \ _Generic((b)+0, \ char*: m_string_set_cstr, \ diff --git a/m-tree.h b/m-tree.h index 0ed0f757..92b4e11c 100644 --- a/m-tree.h +++ b/m-tree.h @@ -217,7 +217,7 @@ typedef int32_t m_tr33_index_t; \ M_P(void, name, _reset, tree_t tree) { \ M_TR33_CONTRACT(tree); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ if (tree->size > 0) { \ /* We don't scan recursively the node tree, but sequentially */ \ m_tr33_index_t free_index = tree->free_index; \ @@ -863,7 +863,7 @@ typedef int32_t m_tr33_index_t; \ M_P(bool, name, _remove, it_t it) { \ M_TR33_IT_CONTRACT(it, false); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ if (M_UNLIKELY(it.index < 0)) { return false; } \ type *ptr = M_F(name, _unlink)(it); \ M_CALL_CLEAR(oplist, *ptr); \ diff --git a/m-tuple.h b/m-tuple.h index d9b97b51..a83df23d 100644 --- a/m-tuple.h +++ b/m-tuple.h @@ -244,7 +244,7 @@ namespace m_lib { /* Define the INIT method calling the INIT method for all params */ #define M_TUPL3_DEFINE_INIT(name, ...) \ M_P(void, name, _init, M_F(name,_ct) my) { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_INIT_FUNC , __VA_ARGS__) {} \ } @@ -255,7 +255,7 @@ namespace m_lib { #define M_TUPL3_DEFINE_INIT_SET(name, ...) \ M_P(void, name, _init_set, M_F(name,_ct) my , M_F(name,_ct) const org) { \ M_TUPL3_CONTRACT(org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_INIT_SET_FUNC , __VA_ARGS__) {} \ } #define M_TUPL3_DEFINE_INIT_SET_FUNC(a) \ @@ -265,7 +265,7 @@ namespace m_lib { /* Define the INIT_WITH method calling the INIT_SET method for all params. */ #define M_TUPL3_DEFINE_INIT_SET2(name, ...) \ M_P(void, name, _init_emplace, M_F(name,_ct) my M_MAP(M_TUPL3_DEFINE_SET2_PROTO, __VA_ARGS__) ) { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_INIT_SET2_FUNC , __VA_ARGS__) {} \ } @@ -279,7 +279,7 @@ namespace m_lib { M_P(void, name, _set, M_F(name,_ct) my, M_F(name,_ct) const org) { \ M_TUPL3_CONTRACT(my); \ M_TUPL3_CONTRACT(org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_SET_FUNC , __VA_ARGS__) \ } @@ -291,7 +291,7 @@ namespace m_lib { #define M_TUPL3_DEFINE_SET2(name, ...) \ M_P(void, name, _emplace, M_F(name,_ct) my M_MAP(M_TUPL3_DEFINE_SET2_PROTO, __VA_ARGS__) ) { \ M_TUPL3_CONTRACT(my); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_SET2_FUNC , __VA_ARGS__) \ } #define M_TUPL3_DEFINE_SET2_PROTO(a) \ @@ -305,7 +305,7 @@ namespace m_lib { #define M_TUPL3_DEFINE_CLEAR(name, ...) \ M_P(void, name, _clear, M_F(name,_ct) my) { \ M_TUPL3_CONTRACT(my); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_CLEAR_FUNC , __VA_ARGS__) \ } @@ -343,7 +343,7 @@ namespace m_lib { M_INLINE void M_C3(name, _set_, M_TUPL3_GET_FIELD a) \ (M_P_EXPAND M_F(name,_ct) my, M_TUPL3_GET_TYPE a const M_TUPL3_GET_FIELD a) { \ M_TUPL3_CONTRACT(my); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_TUPL3_CALL_SET(a, my ->M_TUPL3_GET_FIELD a, M_TUPL3_GET_FIELD a); \ } @@ -362,7 +362,7 @@ namespace m_lib { function_name(M_P_EXPAND name_t v \ M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \ { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_CALL_CLEAR(oplist, v->name); \ M_EMPLACE_CALL_FUNC(a, init_func, oplist, v->name, exp_emplace_type); \ } @@ -508,7 +508,7 @@ namespace m_lib { { \ bool comma = false; \ M_TUPL3_CONTRACT(el); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT (f != NULL); \ int c = fgetc(f); \ if (c != '(') return false; \ @@ -533,7 +533,7 @@ namespace m_lib { { \ M_TUPL3_CONTRACT(el); \ M_ASSERT (str != NULL); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ bool success = false; \ bool comma = false; \ int c = *str++; \ @@ -592,7 +592,7 @@ namespace m_lib { M_P(m_serial_return_code_t, name, _in_serial, M_F(name,_ct) el, m_serial_read_t f) \ { \ M_TUPL3_CONTRACT(el); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_ASSERT (f != NULL && f->m_interface != NULL); \ int index = -1; \ const int field_max = M_NARGS(__VA_ARGS__); \ @@ -637,7 +637,7 @@ namespace m_lib { #define M_TUPL3_DEFINE_MOVE(name, ...) \ M_P(void, name, _move, M_F(name,_ct) el, M_F(name,_ct) org) { \ M_TUPL3_CONTRACT(el); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_MOVE_FUNC , __VA_ARGS__) \ } @@ -661,7 +661,7 @@ namespace m_lib { #define M_TUPL3_DEFINE_RESET(name, ...) \ M_P(void, name, _reset, M_F(name,_ct) el1) { \ M_TUPL3_CONTRACT(el1); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ M_MAP(M_TUPL3_DEFINE_RESET_FUNC , __VA_ARGS__) \ } \ @@ -746,7 +746,7 @@ namespace m_lib { ((M_LIB_ERROR(ONE_ARGUMENT_OF_M_TUPL3_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__))) /* Define the TUPLE oplist */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_TUPL3_OPLIST_P3(name, ...) \ (M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_F(name,_init)),), \ INIT_SET(M_F(name, _init_set)), \ diff --git a/m-variant.h b/m-variant.h index 506a6046..2349f18a 100644 --- a/m-variant.h +++ b/m-variant.h @@ -227,7 +227,7 @@ M_P(void, name, _init_set, M_F(name,_ct) my, M_F(name,_ct) const org) \ { \ M_VAR1ANT_CONTRACT(name, org); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ my->type = org->type; \ switch (org->type) { \ M_MAP2(M_VAR1ANT_DEFINE_INIT_SET_FUNC, name, __VA_ARGS__) \ @@ -278,7 +278,7 @@ M_P(void, name, _clear, M_F(name,_ct) my) \ { \ M_VAR1ANT_CONTRACT(name, my); \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ switch (my->type) { \ M_MAP2(M_VAR1ANT_DEFINE_CLEAR_FUNC, name, __VA_ARGS__) \ case M_F(name, _EMPTY): /* fallthrough */ \ @@ -322,7 +322,7 @@ M_INLINE void \ M_C3(name, _init_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my) \ { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ /* Reinit variable with the given value */ \ my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value); \ M_VAR1ANT_CALL_INIT(a, my -> value. M_VAR1ANT_GET_FIELD a); \ @@ -337,7 +337,7 @@ M_INLINE void \ M_C3(name, _init_set_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my, M_VAR1ANT_GET_TYPE a const M_VAR1ANT_GET_FIELD a) \ { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value); \ M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a, \ M_VAR1ANT_GET_FIELD a); \ @@ -345,7 +345,7 @@ M_INLINE void \ M_C4(m_var1ant_, name, _init_set_, num)(M_P_EXPAND M_F(name,_ct) my, M_VAR1ANT_GET_TYPE a const M_VAR1ANT_GET_FIELD a) \ { \ - M_ASSERT_POOL(); \ + M_UNUSED_CONTEXT(); \ my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value); \ M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a, \ M_VAR1ANT_GET_FIELD a); \ @@ -775,7 +775,7 @@ M_INLINE void \ ((M_LIB_ERROR(ONE_ARGUMENT_OF_VARIANT_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__))) /* Define the oplist */ -#ifndef M_USE_POOL +#ifndef M_USE_CONTEXT #define M_VAR1ANT_OPLIST_P3(name, ...) \ (INIT(M_F(name,_init)), \ INIT_SET(M_F(name, _init_set)), \ diff --git a/m-worker.h b/m-worker.h index 50ca1bc3..436ee715 100644 --- a/m-worker.h +++ b/m-worker.h @@ -234,7 +234,7 @@ typedef struct m_worker_sync_s { M_INLINE void \ M_C3(m_work3r_, name, _clear)(struct M_C3(m_worker_, name, _s) *p) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_CLEAR, data, __VA_ARGS__) \ /* TODO: Overload */ \ M_MEMORY_DEL(p); \ @@ -263,7 +263,7 @@ typedef struct m_worker_sync_s { M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD, data, __VA_ARGS__) \ ) \ { \ - M_GLOBAL_POOL(); \ + M_GLOBAL_CONTEXT(); \ if (!m_work3r_queue_full_p(block->worker->queue_g)) { \ struct M_C3(m_worker_, name, _s) *p = M_MEMORY_ALLOC ( struct M_C3(m_worker_, name, _s)); \ if (M_UNLIKELY_NOMEM(p == NULL)) { \ @@ -362,7 +362,7 @@ m_work3r_thread(void *arg) { // Get back the given argument struct m_worker_s *g = M_ASSIGN_CAST(struct m_worker_s *, arg); - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); while (true) { m_work3r_order_ct w; // If needed, reset the global state of the worker @@ -411,7 +411,7 @@ m_worker_init(m_worker_t g, int numWorker, unsigned int extraQueue, void (*reset // numWorker can still be 0 if it is a single core cpu (no worker available) M_ASSERT(numWorker >= 0); size_t numWorker_st = (size_t) numWorker; - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); g->worker = M_MEMORY_REALLOC(m_work3r_thread_ct, NULL, 0, numWorker_st); if (M_UNLIKELY_NOMEM (g->worker == NULL)) { M_MEMORY_FULL(m_work3r_thread_ct, numWorker_st); @@ -443,7 +443,7 @@ M_INLINE void m_worker_clear(m_worker_t g) { M_ASSERT (m_work3r_queue_empty_p (g->queue_g)); - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); // Push the terminate order on the queue for(unsigned int i = 0; i < g->numWorker_g; i++) { m_work3r_order_ct w = M_WORK3R_EMPTY_ORDER; @@ -482,7 +482,7 @@ M_INLINE void m_worker_spawn(m_worker_sync_t block, void (*func)(void *data), void *data) { const m_work3r_order_ct w = { block, data, func M_WORK3R_EXTRA_ORDER }; - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g)) && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) { M_WORK3R_DEBUG ("Sending data to thread: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn); @@ -501,7 +501,7 @@ M_INLINE void m_work3r_spawn_block(m_worker_sync_t block, void (^func)(void *data), void *data) { const m_work3r_order_ct w = { block, data, NULL, func }; - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g)) && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) { M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn); @@ -521,7 +521,7 @@ M_INLINE void m_work3r_spawn_function(m_worker_sync_t block, std::function func, void *data) { const m_work3r_order_ct w = { block, data, NULL, func }; - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g)) && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) { M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn); @@ -564,7 +564,7 @@ M_INLINE void m_worker_flush(m_worker_t g) { m_work3r_order_ct w; - M_GLOBAL_POOL(); + M_GLOBAL_CONTEXT(); while (m_work3r_queue_pop_blocking (&w, g->queue_g, false) == true) { m_work3r_exec(&w); m_work3r_queue_pop_release(g->queue_g);