[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,132 @@ TEST_F(test, disjointPoolName) {
     umfDisjointPoolParamsDestroy(params);
 }
 
+TEST_F(test, disjointPoolDefaultParams) {
+    // Disjoint pool defaults
+    static constexpr size_t DefaultSlabMinSize = 64 * 1024;           // 64K
+    static constexpr size_t DefaultMaxPoolableSize = 2 * 1024 * 1024; // 2MB
+
+    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);
+
+    int expected_free_counter = 0;
+    static int free_counter = 0;
+    static int last_requested_size = 0;
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            last_requested_size = size;
+            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
+            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();
+
+    res = umfDisjointPoolParamsSetTrace(params, 3);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    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, DefaultSlabMinSize - 1); // Should use pool
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(last_requested_size, DefaultSlabMinSize); // First allocated size should be at least the slab min size
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, expected_free_counter);
+
+    // Test allocation and deallocation with a different size
+    expected_free_counter = 1;
+    ptr = umfPoolMalloc(pool, 2 * DefaultMaxPoolableSize); // Fallback to provider
+    ASSERT_EQ(last_requested_size, 2 * DefaultMaxPoolableSize);
+    ASSERT_NE(ptr, nullptr);
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, expected_free_counter);
+
+    // Cleaning up
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+    expected_free_counter = 2;
+    ASSERT_EQ(free_counter, expected_free_counter);
+}
+
+TEST_F(test, disjointPoolDefaultCapacity) {
+    // Disjoint pool defaults
+    static constexpr size_t DefaultSlabMinSize = 64 * 1024;           // 64K
+    static constexpr size_t DefaultCapacity = 4;
+
+    static int last_requested_size = 0;
+    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 {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            last_requested_size = size;
+            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
+            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));
+    umf_memory_provider_handle_t provider_handle = providerUnique.get();
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t ret = umfDisjointPoolParamsCreate(&params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(umfDisjointPoolOps(), provider_handle,
+                                     params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        // Test capacity
+    void *ptrs[DefaultCapacity + 1];
+    for (size_t i = 0; i < DefaultCapacity + 1; ++i) {
+        ptrs[i] = umfPoolMalloc(pool, DefaultSlabMinSize - 1); // Should use pool
+        ASSERT_NE(ptrs[i], nullptr);
+        ASSERT_EQ(last_requested_size, DefaultSlabMinSize);
+    }
+
+    size_t i;
+    for (i = 0; i < DefaultCapacity + 1; ++i) {
+        ret = umfPoolFree(pool, ptrs[i]);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+    ASSERT_EQ(free_counter, i - DefaultCapacity); // only the last allocation exceeds the capacity
+
+    // Cleaning up
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+    ASSERT_EQ(free_counter, DefaultCapacity + 1); // +1 for the last allocation that exceeded the capacity
+}
+
 INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfDisjointPoolOps(), defaultDisjointPoolConfig,