use the provider's GetCachelineSize() to calculate bucket sizes in DP

Author: bratpiorka

include/umf/pools/pool_disjoint.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2025 Intel Corporation
+ * Copyright (C) 2023-2026 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -82,7 +82,7 @@ umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
                                  size_t maxCapacity);
 
 /// @brief Set minimum bucket allocation size.
-/// @details Default value for minimum bucket size is 8.
+/// @details If not set, the pool uses the provider cache line size.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param minBucketSize minimum bucket size. Must be power of 2.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.

src/pool/pool_disjoint.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2025 Intel Corporation
+ * Copyright (C) 2022-2026 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -1120,6 +1120,7 @@ static const umf_disjoint_pool_params_t default_params = {
     .max_poolable_size = 2 * 1024 * 1024, // 2MB default
     .capacity = 4,                        // default
     .min_bucket_size = 8,                 // default
+    .min_bucket_size_set = false,
     .cur_pool_size = 0,
     .pool_trace = 0,
     .shared_limits = NULL,
@@ -1191,6 +1192,15 @@ umf_result_t disjoint_pool_post_initialize(void *ppPool) {
         goto err_free_disjoint_pool;
     }
 
+    if (!disjoint_pool->params.min_bucket_size_set) {
+        size_t cache_line_size;
+        umf_result_t ret = umfMemoryProviderGetCacheLineSize(
+            disjoint_pool->provider, &cache_line_size);
+        if (ret == UMF_RESULT_SUCCESS) {
+            disjoint_pool->params.min_bucket_size = cache_line_size;
+        }
+    }
+
     // 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.min_bucket_size;
@@ -1733,6 +1743,7 @@ umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
     }
 
     hParams->min_bucket_size = minBucketSize;
+    hParams->min_bucket_size_set = true;
     return UMF_RESULT_SUCCESS;
 }
 

src/pool/pool_disjoint_internal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2025 Intel Corporation
+ * Copyright (C) 2025-2026 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -120,7 +120,8 @@ typedef struct umf_disjoint_pool_params_t {
 
     // Holds the minimum bucket size valid for allocation of a memory type.
     // This value must be a power of 2.
-    size_t min_bucket_size; // Default: 8
+    size_t min_bucket_size; // Default: provider cache line size
+    bool min_bucket_size_set;
 
     // Holds size of the pool managed by the allocator.
     size_t cur_pool_size; // Default: 0

test/pools/disjoint_pool.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025 Intel Corporation
+// Copyright (C) 2023-2026 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -44,6 +44,11 @@ TEST_F(test, internals) {
             *pageSize = 1024;
             return UMF_RESULT_SUCCESS;
         }
+
+        umf_result_t get_cache_line_size(size_t *size) noexcept {
+            *size = 128;
+            return UMF_RESULT_SUCCESS;
+        }
     };
     umf_memory_provider_ops_t provider_ops =
         umf_test::providerMakeCOps<memory_provider, void>();
@@ -78,7 +83,8 @@ TEST_F(test, internals) {
     EXPECT_EQ(pool->provider_min_page_size, (size_t)1024);
 
     // check buckets sizes
-    size_t expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE;
+    size_t expected_size = params->min_bucket_size;
+
     EXPECT_EQ(pool->buckets[0]->size, expected_size);
     EXPECT_EQ(pool->buckets[pool->buckets_num - 1]->size,
               (size_t)1 << 31); // 2GB
@@ -87,12 +93,11 @@ TEST_F(test, internals) {
         EXPECT_NE(bucket, nullptr);
         EXPECT_EQ(bucket->size, expected_size);
 
-        // assuming DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64, expected bucket
-        // sizes are: 64, 96, 128, 192, 256, ..., 2GB
+        // expected bucket sizes are: min, 1.5*min, 2*min, ..., 2GB
         if (i % 2 == 0) {
             expected_size += expected_size / 2;
         } else {
-            expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE << ((i + 1) / 2);
+            expected_size = params->min_bucket_size << ((i + 1) / 2);
         }
     }
 

test/pools/disjoint_pool_ctl.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2025 Intel Corporation
+// Copyright (C) 2025-2026 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exceptiongi
 
@@ -614,10 +614,17 @@ TEST_F(test, disjointCtlBucketStats) {
                              sizeof(count), poolWrapper.get()));
     EXPECT_GE(count, 0ull);
 
-    auto expected_bucket_size = [](size_t i) -> size_t {
-        // Even indexes: 8 << (i/2)  => 8,16,32,64,...
-        // Odd  indexes: 12 << (i/2) => 12,24,48,96,...
-        return (i % 2 == 0) ? (size_t(8) << (i / 2)) : (size_t(12) << (i / 2));
+    size_t min_bucket_size = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                             &min_bucket_size, sizeof(min_bucket_size),
+                             poolWrapper.get()));
+
+    auto expected_bucket_size = [min_bucket_size](size_t i) -> size_t {
+        // Even indexes: min,2*min,4*min,...
+        // Odd  indexes: 1.5*min,3*min,6*min,...
+        return (i % 2 == 0)
+                   ? (min_bucket_size << (i / 2))
+                   : ((min_bucket_size + min_bucket_size / 2) << (i / 2));
     };
 
     for (size_t i = 0; i < count; i++) {