do not allocate slab->iter dynamically

There is no reason to do so. This is only extra performance overhead.

Signed-off-by: Łukasz Plewa <[email protected]>

Author: lplewa

src/pool/pool_disjoint.c

@@ -68,21 +68,16 @@ static slab_t *create_slab(bucket_t *bucket) {
     slab->first_free_chunk_idx = 0;
     slab->bucket = bucket;
 
-    slab->iter = umf_ba_global_alloc(sizeof(*slab->iter));
-    if (slab->iter == NULL) {
-        LOG_ERR("allocation of new slab iter failed!");
-        goto free_slab;
-    }
-    slab->iter->val = slab;
-    slab->iter->prev = slab->iter->next = NULL;
+    slab->iter.val = slab;
+    slab->iter.prev = slab->iter.next = NULL;
 
     slab->num_chunks_total =
         utils_max(bucket_slab_min_size(bucket) / bucket->size, 1);
     slab->chunks =
         umf_ba_global_alloc(sizeof(*slab->chunks) * slab->num_chunks_total);
     if (slab->chunks == NULL) {
         LOG_ERR("allocation of slab chunks failed!");
-        goto free_slab_iter;
+        goto free_slab;
     }
     memset(slab->chunks, 0, sizeof(*slab->chunks) * slab->num_chunks_total);
 
@@ -111,9 +106,6 @@ static slab_t *create_slab(bucket_t *bucket) {
 free_slab_chunks:
     umf_ba_global_free(slab->chunks);
 
-free_slab_iter:
-    umf_ba_global_free(slab->iter);
-
 free_slab:
     umf_ba_global_free(slab);
     return NULL;
@@ -131,7 +123,6 @@ static void destroy_slab(slab_t *slab) {
     }
 
     umf_ba_global_free(slab->chunks);
-    umf_ba_global_free(slab->iter);
     umf_ba_global_free(slab);
 }
 
@@ -296,7 +287,7 @@ static void bucket_free_chunk(bucket_t *bucket, void *ptr, slab_t *slab,
     // in case if the slab was previously full and now has single available
     // chunk, it should be moved to the list of available slabs
     if (slab_get_num_free_chunks(slab) == 1) {
-        slab_list_item_t *slab_it = slab->iter;
+        slab_list_item_t *slab_it = &slab->iter;
         assert(slab_it->val != NULL);
         DL_DELETE(bucket->unavailable_slabs, slab_it);
         DL_PREPEND(bucket->available_slabs, slab_it);
@@ -312,7 +303,7 @@ static void bucket_free_chunk(bucket_t *bucket, void *ptr, slab_t *slab,
         *to_pool = bucket_can_pool(bucket);
         if (*to_pool == false) {
             // remove slab
-            slab_list_item_t *slab_it = slab->iter;
+            slab_list_item_t *slab_it = &slab->iter;
             assert(slab_it->val != NULL);
             slab_unreg(slab_it->val);
             DL_DELETE(bucket->available_slabs, slab_it);
@@ -364,7 +355,7 @@ static slab_t *bucket_create_slab(bucket_t *bucket) {
         return NULL;
     }
 
-    DL_PREPEND(bucket->available_slabs, slab->iter);
+    DL_PREPEND(bucket->available_slabs, &slab->iter);
     bucket->available_slabs_num++;
     bucket_update_stats(bucket, 1, 0);
 

src/pool/pool_disjoint_internal.h

@@ -81,6 +81,11 @@ typedef struct bucket_t {
     size_t max_slabs_in_use;
 } bucket_t;
 
+typedef struct slab_list_item_t {
+    slab_t *val;
+    struct slab_list_item_t *prev, *next;
+} slab_list_item_t;
+
 // Represents the allocated memory block of size 'slab_min_size'
 // Internally, it splits the memory block into chunks. The number of
 // chunks depends on the size of a Bucket which created the Slab.
@@ -107,14 +112,9 @@ typedef struct slab_t {
 
     // Store iterator to the corresponding node in avail/unavail list
     // to achieve O(1) removal
-    slab_list_item_t *iter;
+    slab_list_item_t iter;
 } slab_t;
 
-typedef struct slab_list_item_t {
-    slab_t *val;
-    struct slab_list_item_t *prev, *next;
-} slab_list_item_t;
-
 typedef struct umf_disjoint_pool_shared_limits_t {
     size_t max_size;
     size_t total_size; // requires atomic access