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
@@ -1191,6 +1191,15 @@ umf_result_t disjoint_pool_post_initialize(void *ppPool) {
         goto err_free_disjoint_pool;
     }
 
+    if (!(disjoint_pool->params_overridden & DP_OVERRIDE_MIN_BUCKET_SIZE)) {
+        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;

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,7 @@ 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
 
     // 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,11 @@ 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 cacheline_size = 0;
+    res = umfMemoryProviderGetCacheLineSize(provider_handle, &cacheline_size);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    size_t expected_size = cacheline_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 +96,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: 128, 192, 256, ..., 2GB
         if (i % 2 == 0) {
             expected_size += expected_size / 2;
         } else {
-            expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE << ((i + 1) / 2);
+            expected_size = cacheline_size << ((i + 1) / 2);
         }
     }