Create only one base allocator for all pools and providers

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

src/memory_pool_default.c

@@ -7,12 +7,13 @@
  *
  */
 
-#include "memory_pool_internal.h"
+#include <assert.h>
+#include <stdlib.h>
 
 #include <umf/memory_pool.h>
 
-#include <assert.h>
-#include <stdlib.h>
+#include "memory_pool_internal.h"
+#include "memory_provider_internal.h"
 
 umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
                                    umf_memory_provider_handle_t provider,
@@ -24,28 +25,28 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
 
-    umf_ba_linear_pool_t *pool_linear =
-        umf_ba_linear_create(0 /* minimum pool size */);
-    if (!pool_linear) {
+    int rv = umfBaseAllocatorCreate();
+    if (rv) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_memory_pool_handle_t pool =
-        umf_ba_linear_alloc(pool_linear, sizeof(umf_memory_pool_t));
+    assert(sizeof(umf_memory_pool_t) < SIZE_LBA_POOL_CHUNK);
+
+    umf_memory_pool_handle_t pool = umf_ba_alloc(LBA_pool);
     if (!pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     assert(ops->version == UMF_VERSION_CURRENT);
 
-    pool->pool_linear = pool_linear;
     pool->provider = provider;
     pool->own_provider = false;
 
     pool->ops = *ops;
     ret = ops->initialize(pool->provider, params, &pool->pool_priv);
     if (ret != UMF_RESULT_SUCCESS) {
-        umf_ba_linear_destroy(pool_linear); // it frees pool
+        umf_ba_free(LBA_pool, pool);
+        umfBaseAllocatorDestroy();
         return ret;
     }
 
@@ -61,7 +62,8 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
         umfPoolGetMemoryProvider(hPool, &hProvider);
         umfMemoryProviderDestroy(hProvider);
     }
-    umf_ba_linear_destroy(hPool->pool_linear); // it frees hPool
+    umf_ba_free(LBA_pool, hPool);
+    umfBaseAllocatorDestroy();
 }
 
 umf_result_t umfFree(void *ptr) {

src/memory_pool_internal.h

@@ -21,8 +21,6 @@
 extern "C" {
 #endif
 
-#include "base_alloc_linear.h"
-
 typedef struct umf_memory_pool_t {
     void *pool_priv;
     umf_memory_pool_ops_t ops;
@@ -31,9 +29,6 @@ typedef struct umf_memory_pool_t {
     umf_memory_provider_handle_t provider;
     // Tells whether memory provider is owned by the pool.
     bool own_provider;
-
-    // linear base allocator used by the pool
-    umf_ba_linear_pool_t *pool_linear;
 } umf_memory_pool_t;
 
 umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,

src/memory_pool_tracking.c

@@ -26,20 +26,18 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
 
-    umf_ba_linear_pool_t *pool_linear =
-        umf_ba_linear_create(0 /* minimum pool size */);
-    if (!pool_linear) {
+    int rv = umfBaseAllocatorCreate();
+    if (rv) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_memory_pool_handle_t pool =
-        umf_ba_linear_alloc(pool_linear, sizeof(umf_memory_pool_t));
+    assert(sizeof(umf_memory_pool_t) < SIZE_LBA_POOL_CHUNK);
+
+    umf_memory_pool_handle_t pool = umf_ba_alloc(LBA_pool);
     if (!pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    pool->pool_linear = pool_linear;
-
     assert(ops->version == UMF_VERSION_CURRENT);
 
     // wrap provider with memory tracking provider
@@ -61,7 +59,8 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 err_pool_init:
     umfMemoryProviderDestroy(pool->provider);
 err_provider_create:
-    umf_ba_linear_destroy(pool_linear); // it frees pool
+    umf_ba_free(LBA_pool, pool);
+    umfBaseAllocatorDestroy();
 
     return ret;
 }
@@ -76,7 +75,8 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
     }
     // Destroy tracking provider.
     umfMemoryProviderDestroy(hPool->provider);
-    umf_ba_linear_destroy(hPool->pool_linear); // it frees hPool
+    umf_ba_free(LBA_pool, hPool);
+    umfBaseAllocatorDestroy();
 }
 
 umf_result_t umfFree(void *ptr) {

src/memory_provider.c

@@ -13,46 +13,74 @@
 
 #include <umf/memory_provider.h>
 
-#include "base_alloc_linear.h"
 #include "memory_provider_internal.h"
 #include "utils_common.h"
+#include "utils_concurrency.h"
+
+// base allocator used by all providers and pools
+umf_ba_pool_t *LBA_pool = NULL;
+
+// reference counter of the global base allocator
+static int N_refs_LBA_pool = 0;
 
 typedef struct umf_memory_provider_t {
     umf_memory_provider_ops_t ops;
     void *provider_priv;
-
-    // linear base allocator used by the provider
-    umf_ba_linear_pool_t *pool_linear;
 } umf_memory_provider_t;
 
+int umfBaseAllocatorCreate(void) {
+    if (LBA_pool == NULL) {
+        umf_ba_pool_t *ba_pool = umf_ba_create(SIZE_LBA_POOL_CHUNK);
+        if (!ba_pool) {
+            return -1;
+        }
+
+        if (!util_atomic_bool_compare_exchange(&LBA_pool, NULL, ba_pool)) {
+            umf_ba_destroy(ba_pool);
+        }
+    }
+
+    util_atomic_increment(&N_refs_LBA_pool);
+
+    assert(LBA_pool != NULL);
+    return 0;
+}
+
+void umfBaseAllocatorDestroy(void) {
+    if (util_atomic_decrement(&N_refs_LBA_pool) == 0) {
+        umf_ba_destroy(LBA_pool);
+        LBA_pool = NULL;
+    }
+}
+
 umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
                                      void *params,
                                      umf_memory_provider_handle_t *hProvider) {
     if (!ops || !hProvider) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_ba_linear_pool_t *pool_linear =
-        umf_ba_linear_create(0 /* minimum pool size */);
-    if (!pool_linear) {
+    int rv = umfBaseAllocatorCreate();
+    if (rv) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_memory_provider_handle_t provider =
-        umf_ba_linear_alloc(pool_linear, sizeof(umf_memory_provider_t));
+    assert(sizeof(umf_memory_provider_t) < SIZE_LBA_POOL_CHUNK);
+
+    umf_memory_provider_handle_t provider = umf_ba_alloc(LBA_pool);
     if (!provider) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     assert(ops->version == UMF_VERSION_CURRENT);
 
-    provider->pool_linear = pool_linear;
     provider->ops = *ops;
 
     void *provider_priv;
     umf_result_t ret = ops->initialize(params, &provider_priv);
     if (ret != UMF_RESULT_SUCCESS) {
-        umf_ba_linear_destroy(pool_linear); // it frees provider
+        umf_ba_free(LBA_pool, provider);
+        umfBaseAllocatorDestroy();
         return ret;
     }
 
@@ -65,7 +93,8 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
 
 void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
     hProvider->ops.finalize(hProvider->provider_priv);
-    umf_ba_linear_destroy(hProvider->pool_linear); // it frees hProvider
+    umf_ba_free(LBA_pool, hProvider);
+    umfBaseAllocatorDestroy();
 }
 
 static void

src/memory_provider_internal.h

@@ -16,6 +16,16 @@
 extern "C" {
 #endif
 
+#include "base_alloc.h"
+
+#define SIZE_LBA_POOL_CHUNK 128
+
+// base allocator used by all providers and pools
+extern umf_ba_pool_t *LBA_pool;
+
+int umfBaseAllocatorCreate(void);
+void umfBaseAllocatorDestroy(void);
+
 void *umfMemoryProviderGetPriv(umf_memory_provider_handle_t hProvider);
 umf_memory_provider_handle_t *umfGetLastFailedMemoryProviderPtr(void);