Initialize ba_alloc_global in every pool that is build as a separate lib

Since ba_alloc sources are compiled directly into those pools
they each have a separate copy of base_alloc.

Author: igchor

src/pool/CMakeLists.txt

@@ -4,6 +4,7 @@
 
 if(UMF_BUILD_SHARED_LIBRARY)
     set(POOL_EXTRA_SRCS ${BA_SOURCES})
+    set(POOL_COMPILE_DEFINITIONS UMF_SHARED_LIBRARY)
 endif()
 
 # libumf_pool_disjoint
@@ -12,6 +13,7 @@ if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
                     TYPE STATIC
                     SRCS pool_disjoint.cpp ${POOL_EXTRA_SRCS}
                     LIBS umf_utils)
+    target_compile_definitions(disjoint_pool PUBLIC ${POOL_COMPILE_DEFINITIONS})
 
     add_library(${PROJECT_NAME}::disjoint_pool ALIAS disjoint_pool)
 
@@ -40,6 +42,7 @@ if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
                         TYPE STATIC
                         SRCS pool_jemalloc.c ${POOL_EXTRA_SRCS}
                         LIBS c jemalloc umf_utils)
+        target_compile_definitions(jemalloc_pool PUBLIC ${POOL_COMPILE_DEFINITIONS})
         add_library(${PROJECT_NAME}::jemalloc_pool ALIAS jemalloc_pool)
         install(TARGETS jemalloc_pool
             EXPORT ${PROJECT_NAME}-targets
@@ -56,6 +59,7 @@ if(UMF_BUILD_LIBUMF_POOL_SCALABLE)
                         TYPE STATIC
                         SRCS pool_scalable.c ${POOL_EXTRA_SRCS}
                         LIBS dl umf_utils)
+        target_compile_definitions(scalable_pool PUBLIC ${POOL_COMPILE_DEFINITIONS})
         add_library(${PROJECT_NAME}::scalable_pool ALIAS scalable_pool)
         install(TARGETS scalable_pool
             EXPORT ${PROJECT_NAME}-targets

src/pool/pool_jemalloc.c

@@ -15,12 +15,21 @@
 
 #include "base_alloc_global.h"
 #include "utils_common.h"
+#include "utils_concurrency.h"
 #include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
 #include <umf/pools/pool_jemalloc.h>
 
 #define MALLOCX_ARENA_MAX (MALLCTL_ARENAS_ALL - 1)
 
+#ifdef UMF_SHARED_LIBRARY
+static UTIL_ONCE_FLAG jemalloc_is_initialized = UTIL_ONCE_FLAG_INIT;
+static void jemalloc_global_init(void) {
+    umf_ba_create_global();
+    atexit(umf_ba_destroy_global);
+}
+#endif
+
 typedef struct jemalloc_memory_pool_t {
     umf_memory_provider_handle_t provider;
     unsigned int arena_index; // index of jemalloc arena
@@ -353,6 +362,10 @@ static void *je_aligned_alloc(void *pool, size_t size, size_t alignment) {
 
 static umf_result_t je_initialize(umf_memory_provider_handle_t provider,
                                   void *params, void **out_pool) {
+#ifdef UMF_SHARED_LIBRARY
+    util_init_once(&jemalloc_is_initialized, jemalloc_global_init);
+#endif
+
     assert(provider);
     assert(out_pool);
     (void)params; // unused

src/pool/pool_scalable.c

@@ -25,6 +25,7 @@
 
 #include "base_alloc_global.h"
 #include "utils_common.h"
+#include "utils_concurrency.h"
 #include "utils_sanitizers.h"
 
 typedef void *(*raw_alloc_tbb_type)(intptr_t, size_t *);
@@ -61,15 +62,15 @@ struct tbb_memory_pool {
 };
 
 static struct tbb_callbacks g_tbb_ops;
-static pthread_once_t tbb_is_initialized = PTHREAD_ONCE_INIT;
-static bool Load_tbb_symbols_failed;
+static UTIL_ONCE_FLAG tbb_is_initialized = UTIL_ONCE_FLAG_INIT;
+static bool Init_tbb_global_state_failed;
 
-static void load_tbb_symbols(void) {
+static void init_tbb_global_state(void) {
     const char so_name[] = "libtbbmalloc.so.2";
     void *tbb_handle = dlopen(so_name, RTLD_LAZY);
     if (!tbb_handle) {
         fprintf(stderr, "%s not found.\n", so_name);
-        Load_tbb_symbols_failed = true;
+        Init_tbb_global_state_failed = true;
         return;
     }
 
@@ -99,10 +100,15 @@ static void load_tbb_symbols(void) {
         !tbb_ops.pool_identify) {
         fprintf(stderr, "Could not find symbols in %s.\n", so_name);
         dlclose(tbb_handle);
-        Load_tbb_symbols_failed = true;
+        Init_tbb_global_state_failed = true;
         return;
     }
 
+#ifdef UMF_SHARED_LIBRARY
+    umf_ba_create_global();
+    atexit(umf_ba_destroy_global);
+#endif
+
     g_tbb_ops = tbb_ops;
 }
 
@@ -144,8 +150,8 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
                                        .keep_all_memory = false,
                                        .reserved = 0};
 
-    pthread_once(&tbb_is_initialized, load_tbb_symbols);
-    if (Load_tbb_symbols_failed) {
+    util_init_once(&tbb_is_initialized, init_tbb_global_state);
+    if (Init_tbb_global_state_failed) {
         fprintf(stderr, "loading TBB symbols failed\n");
         return UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -176,7 +182,7 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
 }
 
 static void tbb_pool_finalize(void *pool) {
-    pthread_once(&tbb_is_initialized, load_tbb_symbols);
+    util_init_once(&tbb_is_initialized, init_tbb_global_state);
     struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
     g_tbb_ops.pool_destroy(pool_data->tbb_pool);
     umf_ba_free(pool_data->base_allocator, pool_data);

src/utils/utils_concurrency.h

@@ -36,6 +36,16 @@ void util_mutex_destroy_not_free(os_mutex_t *m);
 int util_mutex_lock(os_mutex_t *mutex);
 int util_mutex_unlock(os_mutex_t *mutex);
 
+#if defined(_WIN32)
+#define UTIL_ONCE_FLAG INIT_ONCE
+#define UTIL_ONCE_FLAG_INIT INIT_ONCE_STATIC_INIT
+#else
+#define UTIL_ONCE_FLAG pthread_once_t
+#define UTIL_ONCE_FLAG_INIT PTHREAD_ONCE_INIT
+#endif
+
+void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
+
 #if defined(_WIN32)
 static __inline unsigned char util_lssb_index(long long value) {
     unsigned long ret;

src/utils/utils_posix_concurrency.c

@@ -33,3 +33,7 @@ int util_mutex_lock(os_mutex_t *m) {
 int util_mutex_unlock(os_mutex_t *m) {
     return pthread_mutex_unlock((pthread_mutex_t *)m);
 }
+
+void util_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) {
+    pthread_once(flag, oneCb);
+}

src/utils/utils_windows_concurrency.c

@@ -39,3 +39,14 @@ int util_mutex_unlock(os_mutex_t *mutex) {
     LeaveCriticalSection(&mutex_internal->lock);
     return 0;
 }
+
+static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
+                                PVOID *lpContext) {
+    void (*onceCb)(void) = (void (*)(void))(Parameter);
+    onceCb();
+    return TRUE;
+}
+
+void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)) {
+    InitOnceExecuteOnce(flag, initOnceCb, (void *)&onceCb, NULL);
+}