Use base allocator in the tracking provider

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

Author: ldorau

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()

src/provider/provider_tracking.c

@@ -20,17 +20,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-typedef struct tracker_value_t {
-    umf_memory_pool_handle_t pool;
-    size_t size;
-} tracker_value_t;
-
 static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
                                         umf_memory_pool_handle_t pool,
                                         const void *ptr, size_t size) {
     assert(ptr);
 
-    tracker_value_t *value = (tracker_value_t *)malloc(sizeof(tracker_value_t));
+    tracker_value_t *value =
+        (tracker_value_t *)umf_ba_alloc(hTracker->pool_tracker);
     value->pool = pool;
     value->size = size;
 
@@ -40,7 +36,7 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
         return UMF_RESULT_SUCCESS;
     }
 
-    free(value);
+    umf_ba_free(hTracker->pool_tracker, value);
 
     if (ret == ENOMEM) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -68,7 +64,7 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    free(value);
+    umf_ba_free(hTracker->pool_tracker, value);
 
     return UMF_RESULT_SUCCESS;
 }
@@ -129,7 +125,7 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
         (umf_tracking_memory_provider_t *)hProvider;
 
     tracker_value_t *splitValue =
-        (tracker_value_t *)malloc(sizeof(tracker_value_t));
+        (tracker_value_t *)umf_ba_alloc(provider->hTracker->pool_tracker);
     if (!splitValue) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -185,15 +181,15 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     (void)cret;
 
     // free the original value
-    free(value);
+    umf_ba_free(provider->hTracker->pool_tracker, value);
     util_mutex_unlock(provider->hTracker->splitMergeMutex);
 
     return UMF_RESULT_SUCCESS;
 
 err:
     util_mutex_unlock(provider->hTracker->splitMergeMutex);
 err_lock:
-    free(splitValue);
+    umf_ba_free(provider->hTracker->pool_tracker, splitValue);
     return ret;
 }
 
@@ -204,7 +200,8 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
         (umf_tracking_memory_provider_t *)hProvider;
 
     tracker_value_t *mergedValue =
-        (tracker_value_t *)malloc(sizeof(tracker_value_t));
+        (tracker_value_t *)umf_ba_alloc(provider->hTracker->pool_tracker);
+
     if (!mergedValue) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -260,13 +257,13 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
     (void)cret;
 
     // free old value that we just replaced with mergedValue
-    free(lowValue);
+    umf_ba_free(provider->hTracker->pool_tracker, lowValue);
 
     void *erasedhighValue =
         critnib_remove(provider->hTracker->map, (uintptr_t)highPtr);
     assert(erasedhighValue == highValue);
 
-    free(erasedhighValue);
+    umf_ba_free(provider->hTracker->pool_tracker, erasedhighValue);
 
     util_mutex_unlock(provider->hTracker->splitMergeMutex);
 
@@ -275,7 +272,7 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
 err:
     util_mutex_unlock(provider->hTracker->splitMergeMutex);
 err_lock:
-    free(mergedValue);
+    umf_ba_free(provider->hTracker->pool_tracker, mergedValue);
     return ret;
 }
 
@@ -310,9 +307,11 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
 }
 
 static umf_result_t trackingInitialize(void *params, void **ret) {
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)params;
     umf_tracking_memory_provider_t *provider =
-        (umf_tracking_memory_provider_t *)malloc(
-            sizeof(umf_tracking_memory_provider_t));
+        (umf_tracking_memory_provider_t *)umf_ba_linear_alloc(
+            p->hTracker->pool_linear, sizeof(umf_tracking_memory_provider_t));
     if (!provider) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -364,7 +363,10 @@ static void trackingFinalize(void *provider) {
     check_if_tracker_is_empty(p->hTracker, p->pool);
 #endif /* NDEBUG */
 
-    free(provider);
+    (void)provider; // unused in Release build
+    // provider was allocated from the linear allocator,
+    // so it will be freed, when the linear allocator is destroyed
+    // in umfMemoryTrackerDestroy()
 }
 
 static void trackingGetLastError(void *provider, const char **msg,

src/provider/provider_tracking.h

@@ -16,6 +16,8 @@
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 
+#include "base_alloc.h"
+#include "base_alloc_linear.h"
 #include "critnib.h"
 #include "utils_concurrency.h"
 
@@ -25,34 +27,62 @@ extern "C" {
 
 extern umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS;
 
+typedef struct tracker_value_t {
+    umf_memory_pool_handle_t pool;
+    size_t size;
+} tracker_value_t;
+
 struct umf_memory_tracker_t {
+    umf_ba_linear_pool_t *pool_linear;
+    umf_ba_pool_t *pool_tracker;
     critnib *map;
     os_mutex_t *splitMergeMutex;
 };
 
 typedef struct umf_memory_tracker_t *umf_memory_tracker_handle_t;
 
 static inline umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
-    umf_memory_tracker_handle_t handle = (umf_memory_tracker_handle_t)malloc(
-        sizeof(struct umf_memory_tracker_t));
-    if (!handle) {
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimum pool size */);
+    if (!pool_linear) {
         return NULL;
     }
 
+    umf_ba_pool_t *pool_tracker = umf_ba_create(sizeof(struct tracker_value_t));
+    if (!pool_tracker) {
+        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_pool_tracker;
+    }
+
+    handle->pool_linear = pool_linear;
+    handle->pool_tracker = pool_tracker;
+
     handle->map = critnib_new();
     if (!handle->map) {
-        free(handle);
-        return NULL;
+        goto err_destroy_pool_tracker;
     }
 
-    handle->splitMergeMutex = util_mutex_create();
+    handle->splitMergeMutex = util_mutex_init(
+        umf_ba_linear_alloc(pool_linear, util_mutex_get_size()));
     if (!handle->splitMergeMutex) {
-        critnib_delete(handle->map);
-        free(handle);
-        return NULL;
+        goto err_critnib_delete;
     }
 
     return handle;
+
+err_critnib_delete:
+    critnib_delete(handle->map);
+err_destroy_pool_tracker:
+    umf_ba_destroy(pool_tracker);
+err_destroy_pool_linear:
+    umf_ba_linear_destroy(pool_linear);
+    return NULL;
 }
 
 static inline void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
@@ -61,8 +91,9 @@ static inline void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
     }
 
     critnib_delete(handle->map);
-    util_mutex_destroy(handle->splitMergeMutex);
-    free(handle);
+    util_mutex_destroy_not_free(handle->splitMergeMutex);
+    umf_ba_destroy(handle->pool_tracker);
+    umf_ba_linear_destroy(handle->pool_linear);
 }
 
 umf_memory_tracker_handle_t umfMemoryTrackerGet(void);