[disjoint] Change pool name setting and cleanup

Author: KFilipek

include/umf/pools/pool_disjoint.h

@@ -100,7 +100,7 @@ umf_result_t umfDisjointPoolParamsSetSharedLimits(
 
 /// @brief Set custom name of the disjoint pool to be used in the traces.
 /// @param hParams handle to the parameters of the disjoint pool.
-/// @param name custom name of the pool.
+/// @param name custom name of the pool. Name longer than 64 characters will be truncated.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,

src/pool/pool_disjoint.c

@@ -59,7 +59,7 @@ static __TLS umf_result_t TLS_last_allocation_error;
 // The largest size which is allocated via the allocator.
 // Allocations with size > CutOff bypass the pool and
 // go directly to the provider.
-static size_t CutOff = (size_t)1 << 31; // 2GB
+static const size_t CutOff = (size_t)1 << 31; // 2GB
 
 static size_t bucket_slab_min_size(bucket_t *bucket) {
     return bucket->pool->params.slab_min_size;
@@ -468,7 +468,7 @@ static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
     // get the position of the leftmost set bit
     size_t position = getLeftmostSetBitPos(size);
 
-    bool is_power_of_2 = 0 == (size & (size - 1));
+    bool is_power_of_2 = IS_POWER_OF_2(size);
     bool larger_than_halfway_between_powers_of_2 =
         !is_power_of_2 &&
         (bool)((size - 1) & ((uint64_t)(1) << (position - 1)));
@@ -630,8 +630,9 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     disjoint_pool->buckets_num = 1;
     size_t Size2 = Size1 + Size1 / 2;
     size_t ts2 = Size2, ts1 = Size1;
-    for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2) {
+    while (Size2 < CutOff) {
         disjoint_pool->buckets_num += 2;
+        Size2 *= 2;
     }
     disjoint_pool->buckets = umf_ba_global_alloc(
         sizeof(*disjoint_pool->buckets) * disjoint_pool->buckets_num);
@@ -767,6 +768,14 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
     return aligned_ptr;
 }
 
+static size_t get_chunk_idx(void *ptr, slab_t *slab) {
+    return (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
+}
+
+static void *get_unaligned_ptr(size_t chunk_idx, slab_t *slab) {
+    return (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+}
+
 size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
     disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
     if (ptr == NULL) {
@@ -788,10 +797,8 @@ size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
     }
     // Get the unaligned pointer
     // NOTE: the base pointer slab->mem_ptr needn't to be aligned to bucket size
-    size_t chunk_idx =
-        (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
-    void *unaligned_ptr =
-        (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+    size_t chunk_idx = get_chunk_idx(ptr, slab);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
 
     ptrdiff_t diff = (ptrdiff_t)ptr - (ptrdiff_t)unaligned_ptr;
 
@@ -847,10 +854,8 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
 
     // Get the unaligned pointer
     // NOTE: the base pointer slab->mem_ptr needn't to be aligned to bucket size
-    size_t chunk_idx =
-        (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
-    void *unaligned_ptr =
-        (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+    size_t chunk_idx = get_chunk_idx(ptr, slab);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
 
     utils_annotate_memory_inaccessible(unaligned_ptr, bucket->size);
     bucket_free_chunk(bucket, unaligned_ptr, slab, &to_pool);
@@ -876,13 +881,11 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
 
 umf_result_t disjoint_pool_get_last_allocation_error(void *pool) {
     (void)pool;
-
     return TLS_last_allocation_error;
 }
 
 // Define destructor for use with unique_ptr
 void disjoint_pool_finalize(void *pool) {
-
     disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
 
     if (hPool->params.pool_trace > 1) {
@@ -937,7 +940,7 @@ void umfDisjointPoolSharedLimitsDestroy(
 
 umf_result_t
 umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
-    static const char *DEFAULT_NAME = "disjoint_pool";
+    static char *DEFAULT_NAME = "disjoint_pool";
 
     if (!hParams) {
         LOG_ERR("disjoint pool params handle is NULL");
@@ -951,20 +954,16 @@ umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    params->slab_min_size = 0;
-    params->max_poolable_size = 0;
-    params->capacity = 0;
-    params->min_bucket_size = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE;
-    params->cur_pool_size = 0;
-    params->pool_trace = 0;
-    params->shared_limits = NULL;
-    params->name = NULL;
-
-    umf_result_t ret = umfDisjointPoolParamsSetName(params, DEFAULT_NAME);
-    if (ret != UMF_RESULT_SUCCESS) {
-        umf_ba_global_free(params);
-        return ret;
-    }
+    *params = (umf_disjoint_pool_params_t){
+        .slab_min_size = 0,
+        .max_poolable_size = 0,
+        .capacity = 0,
+        .min_bucket_size = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE,
+        .cur_pool_size = 0,
+        .pool_trace = 0,
+        .shared_limits = NULL,
+        .name = {*DEFAULT_NAME},
+    };
 
     *hParams = params;
 
@@ -975,7 +974,6 @@ umf_result_t
 umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams) {
     // NOTE: dereferencing hParams when BA is already destroyed leads to crash
     if (hParams && !umf_ba_global_is_destroyed()) {
-        umf_ba_global_free(hParams->name);
         umf_ba_global_free(hParams);
     }
 
@@ -1067,15 +1065,6 @@ umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    char *newName = umf_ba_global_alloc(sizeof(*newName) * (strlen(name) + 1));
-    if (newName == NULL) {
-        LOG_ERR("cannot allocate memory for disjoint pool name");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    umf_ba_global_free(hParams->name);
-    hParams->name = newName;
-    strcpy(hParams->name, name);
-
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
     return UMF_RESULT_SUCCESS;
 }

src/pool/pool_disjoint_internal.h

@@ -131,7 +131,7 @@ typedef struct umf_disjoint_pool_params_t {
     umf_disjoint_pool_shared_limits_handle_t shared_limits;
 
     // Name used in traces
-    char *name;
+    char name[64];
 } umf_disjoint_pool_params_t;
 
 typedef struct disjoint_pool_t {