Replace linear base allocator with the global one

src/base_alloc/base_alloc_global.c

@@ -86,9 +86,11 @@ void *umf_ba_global_alloc(size_t size) {
     util_init_once(&ba_is_initialized, umf_ba_create_global);
 
     if (size > BASE_ALLOC.ac_sizes[NUM_ALLOCATION_CLASSES - 1]) {
+#ifndef NDEBUG
         fprintf(stderr,
                 "base_alloc: allocation size larger than the biggest "
                 "allocation class. Falling back to OS memory allocation.\n");
+#endif
         return ba_os_alloc(size);
     }
 

src/critnib/critnib.c

@@ -58,7 +58,7 @@
 #include <stddef.h>
 
 #include "base_alloc.h"
-#include "base_alloc_linear.h"
+#include "base_alloc_global.h"
 #include "critnib.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -130,7 +130,6 @@ struct critnib {
 
     struct os_mutex_t mutex; /* writes/removes */
 
-    umf_ba_linear_pool_t *pool_linear;
     umf_ba_pool_t *pool_nodes;
     umf_ba_pool_t *pool_leaves;
 };
@@ -182,23 +181,14 @@ static inline unsigned slice_index(word key, sh_t shift) {
  * critnib_new -- allocates a new critnib structure
  */
 struct critnib *critnib_new(void) {
-    umf_ba_linear_pool_t *pool_linear =
-        umf_ba_linear_create(0 /* minimal pool size */);
-    if (!pool_linear) {
-        return NULL;
-    }
-
-    struct critnib *c =
-        umf_ba_linear_alloc(pool_linear, sizeof(struct critnib));
+    struct critnib *c = umf_ba_global_alloc(sizeof(struct critnib));
     if (!c) {
-        goto err_destroy_pool_linear;
+        return NULL;
     }
 
-    c->pool_linear = pool_linear;
-
     void *mutex_ptr = util_mutex_init(&c->mutex);
     if (!mutex_ptr) {
-        goto err_destroy_pool_linear;
+        goto err_free_critnib;
     }
 
     c->pool_nodes = umf_ba_create(sizeof(struct critnib_node));
@@ -220,8 +210,8 @@ struct critnib *critnib_new(void) {
     umf_ba_destroy(c->pool_nodes);
 err_util_mutex_destroy:
     util_mutex_destroy_not_free(&c->mutex);
-err_destroy_pool_linear:
-    umf_ba_linear_destroy(pool_linear); // free all its allocations and destroy
+err_free_critnib:
+    umf_ba_global_free(c, sizeof(struct critnib));
     return NULL;
 }
 
@@ -250,7 +240,6 @@ void critnib_delete(struct critnib *c) {
         delete_node(c, c->root);
     }
 
-    // mutex is freed in umf_ba_linear_destroy(c->pool_linear) at the end
     util_mutex_destroy_not_free(&c->mutex);
 
     for (struct critnib_node *m = c->deleted_node; m;) {
@@ -272,10 +261,7 @@ void critnib_delete(struct critnib *c) {
 
     umf_ba_destroy(c->pool_nodes);
     umf_ba_destroy(c->pool_leaves);
-    umf_ba_linear_destroy(
-        c->pool_linear); // free all its allocations and destroy
-
-    // 'c' was freed in umf_ba_linear_destroy(c->pool_linear)
+    umf_ba_global_free(c, sizeof(struct critnib));
 }
 
 /*

src/memory_targets/memory_target_numa.c

@@ -17,7 +17,6 @@
 #include "../memory_pool_internal.h"
 #include "base_alloc.h"
 #include "base_alloc_global.h"
-#include "base_alloc_linear.h"
 #include "memory_target_numa.h"
 
 struct numa_memory_target_t {
@@ -51,8 +50,7 @@ static void numa_finalize(void *memTarget) {
 static umf_result_t
 numa_targets_create_nodemask(struct numa_memory_target_t **targets,
                              size_t numTargets, unsigned long **mask,
-                             unsigned *maxnode,
-                             umf_ba_linear_pool_t *linear_allocator) {
+                             unsigned *maxnode, size_t *mask_size) {
     assert(targets);
     assert(mask);
     assert(maxnode);
@@ -83,8 +81,9 @@ numa_targets_create_nodemask(struct numa_memory_target_t **targets,
     unsigned bits_per_long = sizeof(unsigned long) * 8;
     int nrUlongs = (lastBit + bits_per_long) / bits_per_long;
 
-    unsigned long *nodemask = umf_ba_linear_alloc(
-        linear_allocator, (sizeof(unsigned long) * nrUlongs));
+    *mask_size = sizeof(unsigned long) * nrUlongs;
+
+    unsigned long *nodemask = umf_ba_global_alloc(*mask_size);
     if (!nodemask) {
         hwloc_bitmap_free(bitmap);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -94,7 +93,7 @@ numa_targets_create_nodemask(struct numa_memory_target_t **targets,
     hwloc_bitmap_free(bitmap);
 
     if (ret) {
-        // nodemask is freed during destroying linear_allocator
+        umf_ba_global_free(nodemask, *mask_size);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
@@ -116,15 +115,10 @@ static enum umf_result_t numa_memory_provider_create_from_memspace(
 
     unsigned long *nodemask;
     unsigned maxnode;
-
-    umf_ba_linear_pool_t *linear_allocator =
-        umf_ba_linear_create(0 /* minimal pool size */);
-    if (!linear_allocator) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
+    size_t nodemask_size;
 
     umf_result_t ret = numa_targets_create_nodemask(
-        numaTargets, numTargets, &nodemask, &maxnode, linear_allocator);
+        numaTargets, numTargets, &nodemask, &maxnode, &nodemask_size);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }
@@ -137,9 +131,8 @@ static enum umf_result_t numa_memory_provider_create_from_memspace(
     umf_memory_provider_handle_t numaProvider = NULL;
     ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &params,
                                   &numaProvider);
-    umf_ba_linear_destroy(linear_allocator); // nodemask is freed here
+    umf_ba_global_free(nodemask, nodemask_size);
     if (ret) {
-
         return ret;
     }
 

src/memory_targets/memory_target_numa.h

@@ -15,7 +15,6 @@
 
 #include "../memory_target.h"
 #include "../memory_target_ops.h"
-#include "base_alloc_linear.h"
 
 #ifdef __cplusplus
 extern "C" {

src/memspace.c

@@ -38,8 +38,7 @@ static umf_result_t verifyMemTargetsTypes(umf_memspace_handle_t memspace) {
 static umf_result_t memoryTargetHandlesToPriv(umf_memspace_handle_t memspace,
                                               void ***pPrivs) {
     assert(memspace);
-    void **privs = umf_ba_linear_alloc(memspace->linear_allocator,
-                                       sizeof(void *) * memspace->size);
+    void **privs = umf_ba_global_alloc(sizeof(void *) * memspace->size);
     if (privs == NULL) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -70,7 +69,8 @@ umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->pool_create_from_memspace(
         memspace, privs, memspace->size, policy, pool);
-    // privs is freed during destroying memspace->linear_allocator
+
+    umf_ba_global_free(privs, sizeof(void *) * memspace->size);
 
     return ret;
 }
@@ -94,7 +94,8 @@ umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t memspace,
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->memory_provider_create_from_memspace(
         memspace, privs, memspace->size, policy, provider);
-    // privs is freed during destroying memspace->linear_allocator
+
+    umf_ba_global_free(privs, sizeof(void *) * memspace->size);
 
     return ret;
 }
@@ -105,6 +106,7 @@ void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
         umfMemoryTargetDestroy(memspace->nodes[i]);
     }
 
-    umf_ba_linear_destroy(memspace->linear_allocator);
+    umf_ba_global_free(memspace->nodes,
+                       memspace->size * sizeof(umf_memory_target_handle_t));
     umf_ba_global_free(memspace, sizeof(struct umf_memspace_t));
 }

src/memspace_internal.h

@@ -13,7 +13,6 @@
 #include <umf/memspace.h>
 
 #include "base_alloc.h"
-#include "base_alloc_linear.h"
 #include "memory_target.h"
 
 #ifdef __cplusplus
@@ -23,9 +22,6 @@ extern "C" {
 struct umf_memspace_t {
     size_t size;
     umf_memory_target_handle_t *nodes;
-
-    // own local linear base allocator
-    umf_ba_linear_pool_t *linear_allocator;
 };
 
 ///

src/memspaces/memspace_numa.c

@@ -12,7 +12,6 @@
 #include "../memory_targets/memory_target_numa.h"
 #include "../memspace_internal.h"
 #include "base_alloc_global.h"
-#include "base_alloc_linear.h"
 #include "memspace_numa.h"
 
 enum umf_result_t
@@ -30,18 +29,9 @@ umfMemspaceCreateFromNumaArray(size_t *nodeIds, size_t numIds,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_ba_linear_pool_t *linear_allocator =
-        umf_ba_linear_create(0 /* minimal pool size */);
-    if (!linear_allocator) {
-        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        goto err_umf_ba_linear_create;
-    }
-
-    memspace->linear_allocator = linear_allocator;
-
     memspace->size = numIds;
-    memspace->nodes = (umf_memory_target_handle_t *)umf_ba_linear_alloc(
-        linear_allocator, numIds * sizeof(umf_memory_target_handle_t));
+    memspace->nodes = (umf_memory_target_handle_t *)umf_ba_global_alloc(
+        memspace->size * sizeof(umf_memory_target_handle_t));
     if (!memspace->nodes) {
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_nodes_alloc;
@@ -62,12 +52,12 @@ umfMemspaceCreateFromNumaArray(size_t *nodeIds, size_t numIds,
     return UMF_RESULT_SUCCESS;
 
 err_target_create:
+    umf_ba_global_free(memspace->nodes,
+                       memspace->size * sizeof(umf_memory_target_handle_t));
     for (size_t i = 0; i < nodeIdx; i++) {
         umfMemoryTargetDestroy(memspace->nodes[i]);
     }
 err_nodes_alloc:
-    umf_ba_linear_destroy(linear_allocator);
-err_umf_ba_linear_create:
     umf_ba_global_free(memspace, sizeof(struct umf_memspace_t));
     return ret;
 }

src/provider/provider_tracking.c

@@ -464,26 +464,19 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
 }
 
 umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
-    umf_ba_linear_pool_t *pool_linear =
-        umf_ba_linear_create(0 /* minimum pool size */);
-    if (!pool_linear) {
+    umf_memory_tracker_handle_t handle =
+        (umf_memory_tracker_handle_t)umf_ba_global_alloc(
+            sizeof(struct umf_memory_tracker_t));
+    if (!handle) {
         return NULL;
     }
 
     umf_ba_pool_t *tracker_allocator =
         umf_ba_create(sizeof(struct tracker_value_t));
     if (!tracker_allocator) {
-        goto err_destroy_pool_linear;
-    }
-
-    umf_memory_tracker_handle_t handle =
-        (umf_memory_tracker_handle_t)umf_ba_linear_alloc(
-            pool_linear, sizeof(struct umf_memory_tracker_t));
-    if (!handle) {
-        goto err_destroy_tracker_allocator;
+        goto err_free_handle;
     }
 
-    handle->pool_linear = pool_linear;
     handle->tracker_allocator = tracker_allocator;
 
     void *mutex_ptr = util_mutex_init(&handle->splitMergeMutex);
@@ -502,8 +495,8 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
     util_mutex_destroy_not_free(&handle->splitMergeMutex);
 err_destroy_tracker_allocator:
     umf_ba_destroy(tracker_allocator);
-err_destroy_pool_linear:
-    umf_ba_linear_destroy(pool_linear);
+err_free_handle:
+    umf_ba_global_free(handle, sizeof(struct umf_memory_tracker_t));
     return NULL;
 }
 
@@ -519,5 +512,5 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
     critnib_delete(handle->map);
     util_mutex_destroy_not_free(&handle->splitMergeMutex);
     umf_ba_destroy(handle->tracker_allocator);
-    umf_ba_linear_destroy(handle->pool_linear);
+    umf_ba_global_free(handle, sizeof(struct umf_memory_tracker_t));
 }

src/provider/provider_tracking.h

@@ -18,7 +18,6 @@
 #include <umf/memory_provider.h>
 
 #include "base_alloc.h"
-#include "base_alloc_linear.h"
 #include "critnib.h"
 #include "utils_concurrency.h"
 
@@ -27,7 +26,6 @@ extern "C" {
 #endif
 
 struct umf_memory_tracker_t {
-    umf_ba_linear_pool_t *pool_linear;
     umf_ba_pool_t *tracker_allocator;
     critnib *map;
     os_mutex_t splitMergeMutex;