[disjoint] Set default parameters for disjoint pool

Author: KFilipek

include/umf/pools/pool_disjoint.h

@@ -52,6 +52,7 @@ umf_result_t
 umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams);
 
 /// @brief Set minimum allocation size that will be requested from the memory provider.
+/// @details Default value for minimum size of slab's is 64KB.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param slabMinSize minimum allocation size.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -60,6 +61,7 @@ umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
                                     size_t slabMinSize);
 
 /// @brief Set size limit for allocations that are subject to pooling.
+/// @details Default value for maximum poolable size is 2MB.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param maxPoolableSize maximum poolable size.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -68,6 +70,7 @@ umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
 
 /// @brief Set maximum capacity of each bucket. Each bucket will hold a
 ///        max of \p maxCapacity unfreed slabs.
+/// @details Default value for capacity is 4.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param maxCapacity maximum capacity of each bucket.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.

src/pool/pool_disjoint.c

@@ -1085,9 +1085,9 @@ umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
     }
 
     *params = (umf_disjoint_pool_params_t){
-        .slab_min_size = 0,
-        .max_poolable_size = 0,
-        .capacity = 0,
+        .slab_min_size = 64 * 1024,           // 64K
+        .max_poolable_size = 2 * 1024 * 1024, // 2MB
+        .capacity = 4,
         .min_bucket_size = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE,
         .cur_pool_size = 0,
         .pool_trace = 0,

src/pool/pool_disjoint_internal.h

@@ -110,13 +110,13 @@ typedef struct umf_disjoint_pool_shared_limits_t {
 
 typedef struct umf_disjoint_pool_params_t {
     // Minimum allocation size that will be requested from the memory provider.
-    size_t slab_min_size;
+    size_t slab_min_size; // Default: 64KB
 
     // Allocations up to this limit will be subject to chunking/pooling
-    size_t max_poolable_size;
+    size_t max_poolable_size; // Default: 2MB
 
     // When pooling, each bucket will hold a max of 'capacity' unfreed slabs
-    size_t capacity;
+    size_t capacity; // Default: 4
 
     // Holds the minimum bucket size valid for allocation of a memory type.
     // This value must be a power of 2.

test/pools/disjoint_pool.cpp

@@ -356,6 +356,65 @@ TEST_F(test, disjointPoolName) {
     umfDisjointPoolParamsDestroy(params);
 }
 
+TEST_F(test, disjointPoolDefaultParams) {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_memory_pool_handle_t pool = nullptr;
+    umf_memory_provider_handle_t provider_handle = nullptr;
+
+    // Create disjoint pool parameters with default settings
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    static int free_counter = 0;
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            printf("Allocating %zu bytes with alignment %zu\n", size,
+                   alignment);
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            printf("Freeing memory at %p\n", ptr);
+            umf_ba_global_free(ptr);
+            free_counter++;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+    provider_handle = providerUnique.get();
+
+    umf_result_t ret = umfPoolCreate(umfDisjointPoolOps(), provider_handle,
+                                     params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    // Test allocation and deallocation
+    // This will use the default disjoint pool parameters
+    void *ptr = umfPoolMalloc(pool, 64);
+    ASSERT_NE(ptr, nullptr);
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, 0);
+
+    // Test allocation and deallocation with a different size
+    ptr = umfPoolMalloc(pool, 4 * 1024 * 1024);
+    ASSERT_NE(ptr, nullptr);
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, 1);
+
+    // Cleaning up
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+    ASSERT_EQ(free_counter, 2);
+}
+
 INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfDisjointPoolOps(), defaultDisjointPoolConfig,