Improve hashmap

Author: Julian LALU

interface/core/bits/bits_common.h

@@ -68,13 +68,72 @@ namespace hud::common
         /** Returns the number of consecutive 0 bits in the value. */
         [[nodiscard]] static constexpr u32 leading_zeros(u32 value) noexcept
         {
-            return value == 0 ? 32 : 31 - hud::math::floor_log2(u32(value));
+            if (value == 0)
+                return 32;
+            u32 count = 0;
+            if ((value >> 16) == 0)
+            {
+                count += 16;
+                value <<= 16;
+            }
+            if ((value >> 24) == 0)
+            {
+                count += 8;
+                value <<= 8;
+            }
+            if ((value >> 28) == 0)
+            {
+                count += 4;
+                value <<= 4;
+            }
+            if ((value >> 30) == 0)
+            {
+                count += 2;
+                value <<= 2;
+            }
+            if ((value >> 31) == 0)
+            {
+                count += 1;
+            }
+            return count;
         }
 
         /** Returns the number of consecutive 0 bits in the value. */
         [[nodiscard]] static constexpr u32 leading_zeros(u64 value) noexcept
         {
-            return value == 0 ? 64 : 63 - hud::math::floor_log2(value);
+            if (value == 0)
+                return 64;
+            uint64_t count = 0;
+            if ((value >> 32) == 0)
+            {
+                count += 32;
+                value <<= 32;
+            }
+            if ((value >> 48) == 0)
+            {
+                count += 16;
+                value <<= 16;
+            }
+            if ((value >> 56) == 0)
+            {
+                count += 8;
+                value <<= 8;
+            }
+            if ((value >> 60) == 0)
+            {
+                count += 4;
+                value <<= 4;
+            }
+            if ((value >> 62) == 0)
+            {
+                count += 2;
+                value <<= 2;
+            }
+            if ((value >> 63) == 0)
+            {
+                count += 1;
+            }
+            return count;
         }
 
         [[nodiscard]] static constexpr u32 trailing_zeros(u8 value) noexcept

interface/core/containers/hashset.h

@@ -1558,7 +1558,7 @@ namespace hud
             [[nodiscard]] constexpr usize free_slot_before_grow() const noexcept
             {
                 // Remove the sign bit that represent if the map contains deleted slots
-                return free_slot_before_grow_ & ((~size_t {}) >> 1);
+                return free_slot_before_grow_ & ((~usize {}) >> 1);
             }
 
             /** Retrieves the next capacity after a grow. */
@@ -1571,7 +1571,7 @@ namespace hud
             /** Retrieves the max slot count for the given count. */
             [[nodiscard]] constexpr usize compute_max_count(usize count) const noexcept
             {
-                return hud::math::next_power_of_two(count + 1) - 1;
+                return count ? ~usize {} >> hud::bits::leading_zeros(count) : 0;
             }
 
             /** Compute the size of the allocation needed for the given slot count. */

interface/core/math/math.h

@@ -3,6 +3,7 @@
 #include "../templates/bit_cast.h"
 #include "../traits/is_constant_evaluated.h"
 #include <cmath> // FP_SUBNORMAL, etc...
+#include "../bits.h"
 
 namespace hud
 {
@@ -36,13 +37,13 @@ namespace hud
         /** Compute the next power of two. */
         [[nodiscard]] static constexpr u32 next_power_of_two(u32 integral) noexcept
         {
-            return hud::math::next_power_of_two_mask(integral) + 1;
+            return integral == 0 ? 1 : u32 {1} << (32 - hud::bits::leading_zeros(integral - 1));
         }
 
         /** Compute the next power of two. */
         [[nodiscard]] static constexpr u64 next_power_of_two(u64 integral) noexcept
         {
-            return hud::math::next_power_of_two_mask(integral) + 1;
+            return integral == 0 ? 1 : (u64 {1} << (64 - hud::bits::leading_zeros(integral - 1)));
         }
 
         /** Compute the natual logarithm of value. */