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;
@@ -1201,6 +1211,11 @@ umf_result_t disjoint_pool_post_initialize(void *ppPool) {
     // 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 size of the "halfway" bucket, round it up to the next
+    // multiple of min_bucket_size.
+    size_t Size2 = Size1 + Size1 / 2;
+    Size2 = ALIGN_UP_SAFE(Size2, disjoint_pool->params.min_bucket_size);
+
     // Calculate the exponent for min_bucket_size used for finding buckets.
     disjoint_pool->min_bucket_size_exp = (size_t)utils_msb64(Size1);
     if (umfDisjointPoolSharedLimitsCreate(
@@ -1211,11 +1226,10 @@ umf_result_t disjoint_pool_post_initialize(void *ppPool) {
 
     // count number of buckets, start from 1
     disjoint_pool->buckets_num = 1;
-    size_t Size2 = Size1 + Size1 / 2;
-    size_t ts2 = Size2, ts1 = Size1;
-    while (Size2 < CutOff) {
+    size_t ts2 = Size2;
+    while (ts2 < CutOff) {
         disjoint_pool->buckets_num += 2;
-        Size2 *= 2;
+        ts2 *= 2;
     }
 
     disjoint_pool->buckets = umf_ba_global_alloc(
@@ -1225,8 +1239,6 @@ umf_result_t disjoint_pool_post_initialize(void *ppPool) {
     }
 
     size_t i = 0;
-    Size1 = ts1;
-    Size2 = ts2;
     for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2, i += 2) {
         disjoint_pool->buckets[i] = create_bucket(
             Size1, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
@@ -1733,6 +1745,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,19 @@ 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,...
+        // NOTE: all sizes need to be rounded up to the nearest multiple of min_bucket_size
+        size_t size =
+            (i % 2 == 0) ? (min_bucket_size << (i / 2))
+                         : ((min_bucket_size + min_bucket_size / 2) << (i / 2));
+        return ALIGN_UP_SAFE(size, min_bucket_size);
     };
 
     for (size_t i = 0; i < count; i++) {