rebase

Author: bratpiorka

src/pool/pool_disjoint.c

@@ -231,8 +231,9 @@ void slab_unreg(slab_t *slab) {
     slab_unreg_by_addr(end_addr, slab);
 }
 
-bucket_t *create_bucket(size_t sz, disjoint_pool_t *pool,
-                        umf_disjoint_pool_shared_limits_t *shared_limits) {
+bucket_t *
+create_bucket(size_t sz, disjoint_pool_t *pool,
+              umf_disjoint_pool_shared_limits_handle_t shared_limits) {
 
     bucket_t *bucket = (bucket_t *)umf_ba_global_alloc(sizeof(bucket_t));
     if (bucket == NULL) {
@@ -344,7 +345,7 @@ size_t bucket_slab_alloc_size(bucket_t *bucket) {
 }
 
 size_t bucket_slab_min_size(bucket_t *bucket) {
-    return bucket->pool->params.SlabMinSize;
+    return bucket->pool->params.slab_min_size;
 }
 
 slab_list_item_t *bucket_get_avail_full_slab(bucket_t *bucket,
@@ -439,12 +440,12 @@ size_t bucket_capacity(bucket_t *bucket) {
     if (bucket->size <= bucket_chunk_cut_off(bucket)) {
         return 1;
     } else {
-        return bucket->pool->params.Capacity;
+        return bucket->pool->params.capacity;
     }
 }
 
 void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool) {
-    if (bucket->pool->params.PoolTrace == 0) {
+    if (bucket->pool->params.pool_trace == 0) {
         return;
     }
 
@@ -458,7 +459,7 @@ void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool) {
 
     // Increment or decrement current pool sizes based on whether
     // slab was added to or removed from pool.
-    bucket->pool->params.CurPoolSize +=
+    bucket->pool->params.cur_pool_size +=
         in_pool * bucket_slab_alloc_size(bucket);
 }
 
@@ -595,8 +596,8 @@ static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
 
 umf_disjoint_pool_shared_limits_t *
 disjoint_pool_get_limits(disjoint_pool_t *pool) {
-    if (pool->params.SharedLimits) {
-        return pool->params.SharedLimits;
+    if (pool->params.shared_limits) {
+        return pool->params.shared_limits;
     } else {
         return pool->default_shared_limits;
     }
@@ -644,29 +645,6 @@ void disjoint_pool_print_stats(disjoint_pool_t *pool, bool *title_printed,
     }
 }
 
-// TODO remove
-static umf_result_t memoryProviderFree(umf_memory_provider_handle_t hProvider,
-                                       void *ptr) {
-    size_t size = 0;
-
-    if (ptr) {
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t umf_result = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-        if (umf_result == UMF_RESULT_SUCCESS) {
-            size = allocInfo.baseSize;
-        }
-    }
-
-    umf_result_t ret = umfMemoryProviderFree(hProvider, ptr, size);
-    if (ret != UMF_RESULT_SUCCESS) {
-
-        TLS_last_allocation_error = ret;
-        // throw MemoryProviderError{ret};
-        return ret;
-    }
-    return UMF_RESULT_SUCCESS;
-}
-
 void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t size,
                              bool *from_pool) {
     if (size == 0) {
@@ -675,7 +653,7 @@ void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t size,
 
     void *ptr = NULL;
 
-    if (size > pool->params.MaxPoolableSize) {
+    if (size > pool->params.max_poolable_size) {
         umf_result_t ret =
             umfMemoryProviderAlloc(pool->provider, size, 0, &ptr);
         if (ret != UMF_RESULT_SUCCESS) {
@@ -702,7 +680,7 @@ void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t size,
         return NULL;
     }
 
-    if (pool->params.PoolTrace > 1) {
+    if (pool->params.pool_trace > 1) {
         bucket_count_alloc(bucket, from_pool);
     }
 
@@ -757,10 +735,11 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     umf_disjoint_pool_params_t *dp_params =
         (umf_disjoint_pool_params_t *)params;
 
-    // MinBucketSize parameter must be a power of 2 for bucket sizes
+    // min_bucket_size parameter must be a power of 2 for bucket sizes
     // to generate correctly.
-    if (!dp_params->MinBucketSize ||
-        !((dp_params->MinBucketSize & (dp_params->MinBucketSize - 1)) == 0)) {
+    if (!dp_params->min_bucket_size ||
+        !((dp_params->min_bucket_size & (dp_params->min_bucket_size - 1)) ==
+          0)) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -774,15 +753,15 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 
     // Generate buckets sized such as: 64, 96, 128, 192, ..., CutOff.
     // Powers of 2 and the value halfway between the powers of 2.
-    size_t Size1 = disjoint_pool->params.MinBucketSize;
+    size_t Size1 = disjoint_pool->params.min_bucket_size;
 
-    // MinBucketSize cannot be larger than CutOff.
+    // min_bucket_size cannot be larger than CutOff.
     Size1 = utils_min(Size1, CutOff);
 
     // Buckets sized smaller than the bucket default size- 8 aren't needed.
     Size1 = utils_max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
 
-    // Calculate the exponent for MinBucketSize used for finding buckets.
+    // Calculate the exponent for min_bucket_size used for finding buckets.
     disjoint_pool->min_bucket_size_exp = (size_t)log2Utils(Size1);
     disjoint_pool->default_shared_limits =
         umfDisjointPoolSharedLimitsCreate(SIZE_MAX);
@@ -829,8 +808,8 @@ void *disjoint_pool_malloc(void *pool, size_t size) {
     bool from_pool;
     void *ptr = disjoint_pool_allocate(hPool, size, &from_pool);
 
-    if (hPool->params.PoolTrace > 2) {
-        const char *MT = hPool->params.Name;
+    if (hPool->params.pool_trace > 2) {
+        const char *MT = hPool->params.name;
         (void)MT;
         //std::cout << "Allocated " << std::setw(8) << size << " " << MT
         //          << " bytes from " << (FromPool ? "Pool" : "Provider") << " ->"
@@ -890,7 +869,7 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
     // Check if requested allocation size is within pooling limit.
     // If not, just request aligned pointer from the system.
     from_pool = false;
-    if (aligned_size > disjoint_pool->params.MaxPoolableSize) {
+    if (aligned_size > disjoint_pool->params.max_poolable_size) {
 
         umf_result_t ret = umfMemoryProviderAlloc(disjoint_pool->provider, size,
                                                   alignment, &ptr);
@@ -913,7 +892,7 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
     }
 
     assert(ptr);
-    if (disjoint_pool->params.PoolTrace > 1) {
+    if (disjoint_pool->params.pool_trace > 1) {
         bucket_count_alloc(bucket, from_pool);
     }
 
@@ -922,8 +901,8 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
     annotate_memory_undefined((void *)ALIGN_UP((size_t)ptr, alignment), size);
     return (void *)ALIGN_UP((size_t)ptr, alignment);
 
-    if (disjoint_pool->params.PoolTrace > 2) {
-        const char *MT = disjoint_pool->params.Name;
+    if (disjoint_pool->params.pool_trace > 2) {
+        const char *MT = disjoint_pool->params.name;
         (void)MT;
         //std::cout << "Allocated " << std::setw(8) << size << " " << MT
         //          << " bytes aligned at " << alignment << " from "
@@ -949,17 +928,33 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     }
 
     void *slab_ptr =
-        (void *)ALIGN_DOWN((size_t)ptr, disjoint_pool->params.SlabMinSize);
+        (void *)ALIGN_DOWN((size_t)ptr, disjoint_pool->params.slab_min_size);
 
     // Lock the map on read
     utils_mutex_lock(&disjoint_pool->known_slabs_map_lock);
 
     slab_t *slab =
         (slab_t *)critnib_get(disjoint_pool->known_slabs, (uintptr_t)slab_ptr);
-    //auto Slabs = getKnownSlabs().equal_range(SlabPtr);
+
+    // check if given pointer is allocated inside any Disjoint Pool slab
     if (slab == NULL) {
         utils_mutex_unlock(&disjoint_pool->known_slabs_map_lock);
-        umf_result_t ret = memoryProviderFree(disjoint_pool->provider, ptr);
+
+        // regular free
+        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
+        umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            return ret;
+        }
+
+        size_t size = allocInfo.baseSize;
+        umf_memory_provider_handle_t provider = disjoint_pool->provider;
+        ret = umfMemoryProviderFree(provider, ptr, size);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+        }
+
         return ret;
     }
 
@@ -975,7 +970,7 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
         utils_mutex_unlock(&disjoint_pool->known_slabs_map_lock);
         bucket_t *bucket = slab->bucket;
 
-        if (disjoint_pool->params.PoolTrace > 1) {
+        if (disjoint_pool->params.pool_trace > 1) {
             bucket->free_count++;
         }
 
@@ -994,14 +989,14 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     /*
     if (ret == UMF_RESULT_SUCCESS) {
 
-        if (impl->getParams().PoolTrace > 2) {
+        if (impl->getParams().pool_trace > 2) {
             auto MT = impl->getParams().Name;
             std::cout << "Freed " << MT << " " << ptr << " to "
                       << (ToPool ? "Pool" : "Provider")
                       << ", Current total pool size "
                       << impl->getLimits()->TotalSize.load()
                       << ", Current pool size for " << MT << " "
-                      << impl->getParams().CurPoolSize << "\n";
+                      << impl->getParams().cur_pool_size << "\n";
         }
     }*/
 
@@ -1037,7 +1032,7 @@ void disjoint_pool_finalize(void *pool) {
     umf_ba_global_free(hPool);
 
     /*
-    if (impl->getParams().PoolTrace > 1) {
+    if (impl->getParams().pool_trace > 1) {
         bool TitlePrinted = false;
         size_t HighBucketSize;
         size_t HighPeakSlabsInUse;
@@ -1089,3 +1084,147 @@ void umfDisjointPoolSharedLimitsDestroy(
     umf_disjoint_pool_shared_limits_t *limits) {
     umf_ba_global_free(limits);
 }
+
+umf_result_t
+umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
+    static const char *DEFAULT_NAME = "disjoint_pool";
+
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_disjoint_pool_params_handle_t params =
+        umf_ba_global_alloc(sizeof(umf_disjoint_pool_params_t));
+    if (params == NULL) {
+        LOG_ERR("cannot allocate memory for disjoint pool params");
+        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;
+    }
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams) {
+    if (hParams) {
+        umf_ba_global_free(hParams->name);
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
+                                    size_t slabMinSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->slab_min_size = slabMinSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
+    umf_disjoint_pool_params_handle_t hParams, size_t maxPoolableSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->max_poolable_size = maxPoolableSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
+                                 size_t maxCapacity) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->capacity = maxCapacity;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
+                                      size_t minBucketSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // minBucketSize parameter must be a power of 2 and greater than 0.
+    if (minBucketSize == 0 || (minBucketSize & (minBucketSize - 1))) {
+        LOG_ERR("minBucketSize must be a power of 2 and greater than 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->min_bucket_size = minBucketSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
+                              int poolTrace) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->pool_trace = poolTrace;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetSharedLimits(
+    umf_disjoint_pool_params_handle_t hParams,
+    umf_disjoint_pool_shared_limits_handle_t hSharedLimits) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->shared_limits = hSharedLimits;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
+                             const char *name) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    char *newName = umf_ba_global_alloc(sizeof(char) * (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);
+
+    return UMF_RESULT_SUCCESS;
+}