Use base allocator in critnib

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/critnib/critnib.c

@@ -57,6 +57,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+#include "base_alloc.h"
+#include "base_alloc_linear.h"
 #include "critnib.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -127,6 +129,10 @@ struct critnib {
     uint64_t remove_count;
 
     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;
 };
 
 /*
@@ -176,37 +182,68 @@ static inline unsigned slice_index(word key, sh_t shift) {
  * critnib_new -- allocates a new critnib structure
  */
 struct critnib *critnib_new(void) {
-    struct critnib *c = Zalloc(sizeof(struct critnib));
-    if (!c) {
+    umf_ba_linear_pool_t *pool_linear =
+        umf_ba_linear_create(0 /* minimal pool size */);
+    if (!pool_linear) {
         return NULL;
     }
 
-    c->mutex = util_mutex_create();
+    struct critnib *c =
+        umf_ba_linear_alloc(pool_linear, sizeof(struct critnib));
+    if (!c) {
+        goto err_destroy_pool_linear;
+    }
+
+    c->pool_linear = pool_linear;
+
+    void *mutex_ptr = umf_ba_linear_alloc(pool_linear, util_mutex_get_size());
+    if (!mutex_ptr) {
+        goto err_destroy_pool_linear;
+    }
+
+    c->mutex = util_mutex_init(mutex_ptr);
     if (!c->mutex) {
-        free(c);
-        return NULL;
+        goto err_destroy_pool_linear;
+    }
+
+    c->pool_nodes = umf_ba_create(sizeof(struct critnib_node));
+    if (!c->pool_nodes) {
+        goto err_util_mutex_destroy;
+    }
+
+    c->pool_leaves = umf_ba_create(sizeof(struct critnib_leaf));
+    if (!c->pool_leaves) {
+        goto err_destroy_pool_nodes;
     }
 
     VALGRIND_HG_DRD_DISABLE_CHECKING(&c->root, sizeof(c->root));
     VALGRIND_HG_DRD_DISABLE_CHECKING(&c->remove_count, sizeof(c->remove_count));
 
     return c;
+
+err_destroy_pool_nodes:
+    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
+    return NULL;
 }
 
 /*
  * internal: delete_node -- recursively free (to malloc) a subtree
  */
-static void delete_node(struct critnib_node *__restrict n) {
+static void delete_node(struct critnib *c, struct critnib_node *__restrict n) {
     if (is_leaf(n)) {
-        Free(to_leaf(n));
+        umf_ba_free(c->pool_leaves, to_leaf(n));
     } else {
         for (int i = 0; i < SLNODES; i++) {
             if (n->child[i]) {
-                delete_node(n->child[i]);
+                delete_node(c, n->child[i]);
             }
         }
 
-        Free(n);
+        umf_ba_free(c->pool_nodes, n);
     }
 }
 
@@ -215,29 +252,35 @@ static void delete_node(struct critnib_node *__restrict n) {
  */
 void critnib_delete(struct critnib *c) {
     if (c->root) {
-        delete_node(c->root);
+        delete_node(c, c->root);
     }
 
-    util_mutex_destroy(c->mutex);
+    // 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;) {
         struct critnib_node *mm = m->child[0];
-        Free(m);
+        umf_ba_free(c->pool_nodes, m);
         m = mm;
     }
 
     for (struct critnib_leaf *k = c->deleted_leaf; k;) {
         struct critnib_leaf *kk = k->value;
-        Free(k);
+        umf_ba_free(c->pool_leaves, k);
         k = kk;
     }
 
     for (int i = 0; i < DELETED_LIFE; i++) {
-        Free(c->pending_del_nodes[i]);
-        Free(c->pending_del_leaves[i]);
+        umf_ba_free(c->pool_nodes, c->pending_del_nodes[i]);
+        umf_ba_free(c->pool_leaves, c->pending_del_leaves[i]);
     }
 
-    Free(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)
 }
 
 /*
@@ -264,7 +307,7 @@ static void free_node(struct critnib *__restrict c,
  */
 static struct critnib_node *alloc_node(struct critnib *__restrict c) {
     if (!c->deleted_node) {
-        return Malloc(sizeof(struct critnib_node));
+        return umf_ba_alloc(c->pool_nodes);
     }
 
     struct critnib_node *n = c->deleted_node;
@@ -295,7 +338,7 @@ static void free_leaf(struct critnib *__restrict c,
  */
 static struct critnib_leaf *alloc_leaf(struct critnib *__restrict c) {
     if (!c->deleted_leaf) {
-        return Malloc(sizeof(struct critnib_leaf));
+        return umf_ba_alloc(c->pool_leaves);
     }
 
     struct critnib_leaf *k = c->deleted_leaf;