cleanup bit scan utils

Author: bratpiorka

src/base_alloc/base_alloc_global.c

@@ -71,7 +71,8 @@ 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_get_leftmost_set_bit_pos(smallestSize);
 
     LOG_DEBUG("UMF base allocator created");
 }
@@ -83,8 +84,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_get_leftmost_set_bit_pos(size) + !isPowerOf2 -
+                      BASE_ALLOC.smallest_ac_size_log2);
 
     assert(index >= 0);
     return index;

src/critnib/critnib.c

@@ -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
@@ -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
@@ -386,7 +387,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_get_leftmost_set_bit_pos(at) & (sh_t) ~(SLICE - 1);
 
     struct critnib_node *m = alloc_node(c);
     if (!m) {

src/utils/utils_concurrency.h

@@ -15,10 +15,6 @@
 
 #ifdef _WIN32
 #include <windows.h>
-
-#include "utils_windows_intrin.h"
-
-#pragma intrinsic(_BitScanForward64)
 #else
 #include <pthread.h>
 
@@ -79,18 +75,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...
 #define utils_atomic_load_acquire(object, dest)                                \
     do {                                                                       \
@@ -116,9 +100,6 @@ static __inline unsigned char utils_mssb_index(long long value) {
 
 #else // !defined(_WIN32)
 
-#define utils_lssb_index(x) ((unsigned char)__builtin_ctzll(x))
-#define utils_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x)))
-
 #define utils_atomic_load_acquire(object, dest)                                \
     do {                                                                       \
         utils_annotate_acquire((void *)object);                                \

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
@@ -12,15 +12,14 @@
 
 #include <assert.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-size_t getLeftmostSetBitPos(size_t num);
-
-// Logarithm is an index of the most significant non-zero bit.
-static inline size_t log2Utils(size_t num) { return getLeftmostSetBitPos(num); }
+size_t utils_get_leftmost_set_bit_pos(uint64_t num);
+size_t utils_get_rightmost_set_bit_pos(uint64_t num);
 
 #ifdef __cplusplus
 }

src/utils/utils_posix_math.c

@@ -1,20 +1,27 @@
 /*
  *
- * Copyright (C) 2023 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
  *
  */
 
-#include "utils_math.h"
 #include <limits.h>
 
+#include "utils_math.h"
+
 // 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.
-size_t getLeftmostSetBitPos(size_t num) {
+size_t utils_get_leftmost_set_bit_pos(uint64_t num) {
     assert(num != 0 &&
            "Finding leftmost set bit when number equals zero is undefined");
     return (sizeof(num) * CHAR_BIT - 1) - __builtin_clzll(num);
 }
+
+size_t utils_get_rightmost_set_bit_pos(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    return __builtin_ctzll(num);
+}

src/utils/utils_windows_math.c

@@ -10,15 +10,24 @@
 #include "utils_math.h"
 #include "utils_windows_intrin.h"
 
-#pragma intrinsic(_BitScanReverse)
+#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.
-size_t getLeftmostSetBitPos(size_t num) {
+size_t utils_get_leftmost_set_bit_pos(uint64_t num) {
     assert(num != 0 &&
            "Finding leftmost set bit when number equals zero is undefined");
     unsigned long index = 0;
-    _BitScanReverse(&index, (unsigned long)num);
+    _BitScanReverse64(&index, num);
+    return (size_t)index;
+}
+
+size_t utils_get_rightmost_set_bit_pos(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;
 }