Use base allocator in memory pool, provider and target

ldorau · ldorau · commit cf2bf0c36689 · 2024-01-29T13:16:37.000+01:00
Signed-off-by: Lukasz Dorau &lt;lukasz.dorau@intel.com&gt;
diff --git a/cmake/helpers.cmake b/cmake/helpers.cmake
@@ -104,7 +104,7 @@ function(add_umf_library)
     target_link_libraries(${ARG_NAME} PRIVATE ${ARG_LIBS})
     target_include_directories(${ARG_NAME} PRIVATE
         ${UMF_CMAKE_SOURCE_DIR}/include
-        ${UMF_CMAKE_SOURCE_DIR}/src/common)
+        ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
     add_umf_target_compile_options(${ARG_NAME})
     add_umf_target_link_options(${ARG_NAME})
 endfunction()
diff --git a/src/memory_pool_default.c b/src/memory_pool_default.c
@@ -23,20 +23,29 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     }
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
-    umf_memory_pool_handle_t pool = malloc(sizeof(umf_memory_pool_t));
+
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimum pool size */);
+    if (!pool_linear) {
+        return NULL;
+    }
+
+    umf_memory_pool_handle_t pool =
+        umf_ba_linear_alloc(pool_linear, sizeof(umf_memory_pool_t));
     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) {
-        free(pool);
+        umf_ba_linear_destroy(pool_linear); // it frees pool
         return ret;
     }
 
@@ -52,7 +61,7 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
         umfPoolGetMemoryProvider(hPool, &hProvider);
         umfMemoryProviderDestroy(hProvider);
     }
-    free(hPool);
+    umf_ba_linear_destroy(hPool->pool_linear); // it frees hPool
 }
 
 umf_result_t umfFree(void *ptr) {
diff --git a/src/memory_pool_internal.h b/src/memory_pool_internal.h
@@ -21,6 +21,8 @@
 extern "C" {
 #endif
 
+#include <base_alloc_linear.h>
+
 typedef struct umf_memory_pool_t {
     void *pool_priv;
     umf_memory_pool_ops_t ops;
@@ -29,6 +31,9 @@ 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,
diff --git a/src/memory_pool_tracking.c b/src/memory_pool_tracking.c
@@ -25,11 +25,21 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     }
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
-    umf_memory_pool_handle_t pool = malloc(sizeof(umf_memory_pool_t));
+
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimum pool size */);
+    if (!pool_linear) {
+        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));
     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
@@ -51,7 +61,7 @@ umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 err_pool_init:
     umfMemoryProviderDestroy(pool->provider);
 err_provider_create:
-    free(pool);
+    umf_ba_linear_destroy(pool_linear); // it frees pool
 
     return ret;
 }
@@ -66,7 +76,7 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
     }
     // Destroy tracking provider.
     umfMemoryProviderDestroy(hPool->provider);
-    free(hPool);
+    umf_ba_linear_destroy(hPool->pool_linear); // it frees hPool
 }
 
 umf_result_t umfFree(void *ptr) {
diff --git a/src/memory_provider.c b/src/memory_provider.c
@@ -7,18 +7,22 @@
  *
  */
 
-#include "memory_provider_internal.h"
-#include "utils_common.h"
-
-#include <umf/memory_provider.h>
-
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/memory_provider.h>
+
+#include "memory_provider_internal.h"
+#include "utils_common.h"
+#include <base_alloc_linear.h>
+
 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;
 
 umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
@@ -28,20 +32,27 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimum pool size */);
+    if (!pool_linear) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
     umf_memory_provider_handle_t provider =
-        malloc(sizeof(umf_memory_provider_t));
+        umf_ba_linear_alloc(pool_linear, sizeof(umf_memory_provider_t));
     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) {
-        free(provider);
+        umf_ba_linear_destroy(pool_linear); // it frees provider
         return ret;
     }
 
@@ -54,7 +65,7 @@ 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);
-    free(hProvider);
+    umf_ba_linear_destroy(hProvider->pool_linear); // it frees hProvider
 }
 
 static void
diff --git a/src/memory_target.c b/src/memory_target.c
@@ -20,20 +20,28 @@ umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimum pool size */);
+    if (!pool_linear) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
     umf_memory_target_handle_t target =
-        (umf_memory_target_t *)malloc(sizeof(umf_memory_target_t));
+        (umf_memory_target_t *)umf_ba_linear_alloc(pool_linear,
+                                                   sizeof(umf_memory_target_t));
     if (!target) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     assert(ops->version == UMF_VERSION_CURRENT);
 
+    target->pool_linear = pool_linear;
     target->ops = ops;
 
     void *target_priv;
     umf_result_t ret = ops->initialize(params, &target_priv);
     if (ret != UMF_RESULT_SUCCESS) {
-        free(target);
+        umf_ba_linear_destroy(pool_linear); // it frees target
         return ret;
     }
 
@@ -47,5 +55,5 @@ umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
 void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget) {
     assert(memoryTarget);
     memoryTarget->ops->finalize(memoryTarget->priv);
-    free(memoryTarget);
+    umf_ba_linear_destroy(memoryTarget->pool_linear); // it frees memoryTarget
 }
diff --git a/src/memory_target.h b/src/memory_target.h
@@ -16,12 +16,17 @@
 extern "C" {
 #endif
 
+#include <base_alloc_linear.h>
+
 struct umf_memory_target_ops_t;
 typedef struct umf_memory_target_ops_t umf_memory_target_ops_t;
 
 typedef struct umf_memory_target_t {
     const umf_memory_target_ops_t *ops;
     void *priv;
+
+    // linear base allocator used by the target
+    umf_ba_linear_pool_t *pool_linear;
 } umf_memory_target_t;
 
 typedef umf_memory_target_t *umf_memory_target_handle_t;
