cleanup bit scan utils

Author: bratpiorka

src/base_alloc/base_alloc_global.c

@@ -71,7 +71,7 @@ static void umf_ba_create_global(void) {
     }
 
     size_t smallestSize = BASE_ALLOC.ac_sizes[0];
-    BASE_ALLOC.smallest_ac_size_log2 = log2Utils(smallestSize);
+    BASE_ALLOC.smallest_ac_size_log2 = utils_msb64(smallestSize);
 
     LOG_DEBUG("UMF base allocator created");
 }
@@ -83,8 +83,8 @@ static int size_to_idx(size_t size) {
     }
 
     int isPowerOf2 = (0 == (size & (size - 1)));
-    int index =
-        (int)(log2Utils(size) + !isPowerOf2 - BASE_ALLOC.smallest_ac_size_log2);
+    int index = (int)(utils_msb64(size) + !isPowerOf2 -
+                      BASE_ALLOC.smallest_ac_size_log2);
 
     assert(index >= 0);
     return index;

src/critnib/critnib.c

@@ -64,6 +64,7 @@
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_math.h"
 
 /*
  * A node that has been deleted is left untouched for this many delete
@@ -367,7 +368,7 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
     }
 
     /* and convert that to an index. */
-    sh_t sh = utils_mssb_index(at) & (sh_t) ~(SLICE - 1);
+    sh_t sh = utils_msb64(at) & (sh_t) ~(SLICE - 1);
 
     struct critnib_node *m = alloc_node(c);
     if (!m) {

src/pool/pool_disjoint.c

@@ -466,7 +466,7 @@ static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
     }
 
     // get the position of the leftmost set bit
-    size_t position = getLeftmostSetBitPos(size);
+    size_t position = utils_msb64(size);
 
     bool is_power_of_2 = 0 == (size & (size - 1));
     bool larger_than_halfway_between_powers_of_2 =
@@ -622,7 +622,7 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     Size1 = utils_max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
 
     // Calculate the exponent for min_bucket_size used for finding buckets.
-    disjoint_pool->min_bucket_size_exp = (size_t)log2Utils(Size1);
+    disjoint_pool->min_bucket_size_exp = (size_t)utils_msb64(Size1);
     disjoint_pool->default_shared_limits =
         umfDisjointPoolSharedLimitsCreate(SIZE_MAX);
 

src/utils/CMakeLists.txt

@@ -7,15 +7,14 @@ include(FindThreads)
 
 set(UMF_UTILS_SOURCES_COMMON utils_common.c utils_log.c utils_load_library.c)
 
-set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c
-                            utils_posix_math.c)
+set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c)
 
 set(UMF_UTILS_SOURCES_LINUX utils_linux_common.c)
 
 set(UMF_UTILS_SOURCES_MACOSX utils_macosx_common.c)
 
 set(UMF_UTILS_SOURCES_WINDOWS utils_windows_common.c
-                              utils_windows_concurrency.c utils_windows_math.c)
+                              utils_windows_concurrency.c)
 
 if(UMF_USE_VALGRIND)
     if(UMF_USE_ASAN

src/utils/utils_concurrency.h

@@ -89,18 +89,6 @@ void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
 
 #if defined(_WIN32)
 
-static inline unsigned char utils_lssb_index(long long value) {
-    unsigned long ret;
-    _BitScanForward64(&ret, value);
-    return (unsigned char)ret;
-}
-
-static inline unsigned char utils_mssb_index(long long value) {
-    unsigned long ret;
-    _BitScanReverse64(&ret, value);
-    return (unsigned char)ret;
-}
-
 // There is no good way to do atomic_load on windows...
 static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
     // NOTE: Windows cl complains about direct accessing 'ptr' which is next
@@ -166,9 +154,6 @@ static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
 
 #else // !defined(_WIN32)
 
-#define utils_lssb_index(x) ((unsigned char)__builtin_ctzll(x))
-#define utils_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x)))
-
 static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
     ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
     ASSERT_IS_ALIGNED((uintptr_t)out, 8);

src/utils/utils_math.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,16 +11,58 @@
 #define UMF_MATH_H 1
 
 #include <assert.h>
+#include <limits.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-size_t getLeftmostSetBitPos(size_t num);
+#if defined(_WIN32)
 
-// Logarithm is an index of the most significant non-zero bit.
-static inline size_t log2Utils(size_t num) { return getLeftmostSetBitPos(num); }
+#include "utils_windows_intrin.h"
+
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_BitScanForward64)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanReverse64(&index, num);
+    return (size_t)index;
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanForward64(&index, num);
+    return (size_t)index;
+}
+
+#else // !defined(_WIN32)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    return 63 - __builtin_clzll(num);
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    return __builtin_ctzll(num);
+}
+
+#endif // !defined(_WIN32)
 
 #ifdef __cplusplus
 }