[ntuple] Move LeadingZeroes/TrailingZeroes to BitUtils

Also make them usable for both 32-bit and 64-bit integers.

Author: silverweed

core/foundation/inc/ROOT/BitUtils.hxx

@@ -12,8 +12,14 @@
 #ifndef ROOT_BitUtils
 #define ROOT_BitUtils
 
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <type_traits>
+
+#ifdef _MSC_VER
+#include <intrin.h> // for _BitScan*
+#endif
 
 namespace ROOT {
 namespace Internal {
@@ -35,6 +41,98 @@ inline constexpr T AlignUp(T value, T align) noexcept
    return (value + align - 1) & ~(align - 1);
 }
 
+/// Given an integer `x`, returns the number of leading 0-bits starting at the most significant bit position.
+/// If `x` is 0, it returns the size of `x` in bits.
+///
+/// Example:
+///
+/// if x is a std::uint32_t with value 42 (0b0...0101010), then LeadingZeroes(x) == 26
+template <typename T>
+inline std::size_t LeadingZeroes(T x)
+{
+   constexpr std::size_t maxBits = sizeof(T) * 8;
+   static_assert(std::is_integral_v<T> && (maxBits == 32 || maxBits == 64));
+
+   if (x == 0)
+      return maxBits;
+
+#ifdef _MSC_VER
+   unsigned long idx = 0;
+   [[maybe_unused]] unsigned char nonZero;
+   if constexpr (maxBits == 32) {
+      nonZero = _BitScanReverse(&idx, x);
+   } else {
+#ifdef R__B64
+      // 64-bit machine
+      nonZero = _BitScanReverse64(&idx, x);
+#else
+      // 32-bit machine
+      std::uint32_t low = (x & 0xFFFF'FFFF);
+      std::uint32_t high = (x >> 32) & 0xFFFF'FFFF;
+      unsigned long lowIdx, highIdx;
+      unsigned char lowNonZero = _BitScanReverse(&lowIdx, low);
+      unsigned char highNonZero = _BitScanReverse(&highIdx, high);
+      nonZero = lowNonZero | highNonZero;
+      idx = std::max(highIdx * (highIdx + 32), lowIdx);
+#endif // R__B64
+   }
+   assert(nonZero);
+   return static_cast<std::size_t>(maxBits - 1 - idx);
+#else
+   if constexpr (maxBits == 32) {
+      return static_cast<std::size_t>(__builtin_clz(x));
+   } else {
+      return static_cast<std::size_t>(__builtin_clzl(x));
+   }
+#endif // _MSC_VER
+}
+
+/// Given an integer `x`, returns the number of trailing 0-bits starting at the least significant bit position.
+/// If `x` is 0, it returns the size of `x` in bits.
+///
+/// Example:
+///
+/// if x is a std::uint32_t with value 42 (0b0...0101010), then TrailingZeroes(x) == 1
+template <typename T>
+inline std::size_t TrailingZeroes(T x)
+{
+   constexpr std::size_t maxBits = sizeof(T) * 8;
+   static_assert(std::is_integral_v<T> && (maxBits == 32 || maxBits == 64));
+
+   if (x == 0)
+      return maxBits;
+
+#ifdef _MSC_VER
+   unsigned long idx = 0;
+   [[maybe_unused]] unsigned char nonZero;
+   if constexpr (maxBits == 32) {
+      nonZero = _BitScanForward(&idx, x);
+   } else {
+#ifdef R__B64
+      // 64-bit machine
+      nonZero = _BitScanForward64(&idx, x);
+#else
+      // 32-bit machine
+      std::uint32_t low = (x & 0xFFFF'FFFF);
+      std::uint32_t high = (x >> 32) & 0xFFFF'FFFF;
+      unsigned long lowIdx, highIdx;
+      unsigned char lowNonZero = _BitScanForward(&lowIdx, low);
+      unsigned char highNonZero = _BitScanForward(&highIdx, high);
+      nonZero = lowNonZero | highNonZero;
+      idx = std::min(highIdx * (highIdx + 32), lowIdx);
+#endif // R__B64
+   }
+   assert(nonZero);
+   return static_cast<std::size_t>(idx);
+#else
+   if constexpr (maxBits == 32) {
+      return static_cast<std::size_t>(__builtin_ctz(x));
+   } else {
+      return static_cast<std::size_t>(__builtin_ctzl(x));
+   }
+#endif // _MSC_VER
+   }
+
 } // namespace Internal
 } // namespace ROOT
 

core/foundation/test/CMakeLists.txt

@@ -12,4 +12,5 @@ ROOT_ADD_GTEST(testException testException.cxx LIBRARIES Core GTest::gmock)
 ROOT_ADD_GTEST(testLogger testLogger.cxx LIBRARIES Core)
 ROOT_ADD_GTEST(testRRangeCast testRRangeCast.cxx LIBRARIES Core)
 ROOT_ADD_GTEST(testStringUtils testStringUtils.cxx LIBRARIES Core)
+ROOT_ADD_GTEST(testBitUtils testBitUtils.cxx LIBRARIES Core)
 ROOT_ADD_GTEST(FoundationUtilsTests FoundationUtilsTests.cxx LIBRARIES Core INCLUDE_DIRS ../res)

core/foundation/test/testBitUtils.cxx

@@ -0,0 +1,45 @@
+#include "ROOT/BitUtils.hxx"
+
+#include "gtest/gtest.h"
+
+using namespace ROOT::Internal;
+
+TEST(BitUtils, LeadingZeroes32)
+{
+   EXPECT_EQ(LeadingZeroes(0), 32);
+   EXPECT_EQ(LeadingZeroes(~0), 0);
+   EXPECT_EQ(LeadingZeroes(0xF000'0000), 0);
+   EXPECT_EQ(LeadingZeroes(0x0000'F040), 16);
+   EXPECT_EQ(LeadingZeroes(0x0000'0003), 30);
+   EXPECT_EQ(LeadingZeroes(0x000F'F000), 12);
+}
+
+TEST(BitUtils, LeadingZeroes64)
+{
+   EXPECT_EQ(LeadingZeroes(0ull), 64);
+   EXPECT_EQ(LeadingZeroes(~0ull), 0);
+   EXPECT_EQ(LeadingZeroes(0xF000'0000'0000'0000ull), 0);
+   EXPECT_EQ(LeadingZeroes(0x0000'F000'1000'1000ull), 16);
+   EXPECT_EQ(LeadingZeroes(0x0000'0000'0000'0003ull), 62);
+   EXPECT_EQ(LeadingZeroes(0x0000'000F'F000'0000ull), 28);
+}
+
+TEST(BitUtils, TrailingZeroes32)
+{
+   EXPECT_EQ(TrailingZeroes(0), 32);
+   EXPECT_EQ(TrailingZeroes(~0), 0);
+   EXPECT_EQ(TrailingZeroes(0xF000'0000), 28);
+   EXPECT_EQ(TrailingZeroes(0x0000'F040), 6);
+   EXPECT_EQ(TrailingZeroes(0x0000'0003), 0);
+   EXPECT_EQ(TrailingZeroes(0x000F'F000), 12);
+}
+
+TEST(BitUtils, TrailingZeroes64)
+{
+   EXPECT_EQ(TrailingZeroes(0ull), 64);
+   EXPECT_EQ(TrailingZeroes(~0ull), 0);
+   EXPECT_EQ(TrailingZeroes(0xF000'0000'0000'0000ull), 60);
+   EXPECT_EQ(TrailingZeroes(0x0000'F000'1000'1000ull), 12);
+   EXPECT_EQ(TrailingZeroes(0x0000'0000'0000'0003ull), 0);
+   EXPECT_EQ(TrailingZeroes(0x0000'000F'F000'0000ull), 28);
+}

tree/ntuple/src/RColumnElement.hxx

@@ -7,6 +7,7 @@
 // definitions are implementation details and should not be exposed to a public interface.
 
 #include <ROOT/RColumnElementBase.hxx>
+#include <ROOT/BitUtils.hxx>
 #include <ROOT/RNTupleTypes.hxx>
 #include <ROOT/RNTupleUtils.hxx>
 #include <ROOT/RConfig.hxx>
@@ -1000,36 +1001,6 @@ namespace Quantize {
 
 using Quantized_t = std::uint32_t;
 
-[[maybe_unused]] inline std::size_t LeadingZeroes(std::uint32_t x)
-{
-   if (x == 0)
-      return 32;
-
-#ifdef _MSC_VER
-   unsigned long idx = 0;
-   if (_BitScanReverse(&idx, x))
-      return static_cast<std::size_t>(31 - idx);
-   return 32;
-#else
-   return static_cast<std::size_t>(__builtin_clz(x));
-#endif
-}
-
-[[maybe_unused]] inline std::size_t TrailingZeroes(std::uint32_t x)
-{
-   if (x == 0)
-      return 32;
-
-#ifdef _MSC_VER
-   unsigned long idx = 0;
-   if (_BitScanForward(&idx, x))
-      return static_cast<std::size_t>(idx);
-   return 32;
-#else
-   return static_cast<std::size_t>(__builtin_ctz(x));
-#endif
-}
-
 /// Converts the array `src` of `count` floating point numbers into an array of their quantized representations.
 /// Each element of `src` is assumed to be in the inclusive range [min, max].
 /// The quantized representation will consist of unsigned integers of at most `nQuantBits` (with `nQuantBits <= 8 *
@@ -1065,7 +1036,7 @@ int QuantizeReals(Quantized_t *dst, const T *src, std::size_t count, double min,
       ByteSwapIfNecessary(q);
 
       // double-check we actually used at most `nQuantBits`
-      assert(outOfRange || LeadingZeroes(q) >= unusedBits);
+      assert(outOfRange || ROOT::Internal::LeadingZeroes(q) >= unusedBits);
 
       // we want to leave zeroes in the LSB, not the MSB, because we'll then drop the LSB
       // when bit packing.
@@ -1095,7 +1066,7 @@ int UnquantizeReals(T *dst, const Quantized_t *src, std::size_t count, double mi
    for (std::size_t i = 0; i < count; ++i) {
       Quantized_t elem = src[i];
       // Undo the LSB-preserving shift performed by QuantizeReals
-      assert(TrailingZeroes(elem) >= unusedBits);
+      assert(ROOT::Internal::TrailingZeroes(elem) >= unusedBits);
       elem >>= unusedBits;
       ByteSwapIfNecessary(elem);