Improve hashmap

Author: Julian LALU

interface/core/containers/hashset.h

@@ -917,7 +917,7 @@ namespace hud
             {
                 if (count > max_slot_count_)
                 {
-                    grow_capacity(compute_max_count(count));
+                    resize(compute_max_count(count));
                 }
             }
 
@@ -1021,6 +1021,29 @@ namespace hud
                 }
             }
 
+            constexpr void rehash(i32 count) const noexcept
+            {
+                // If we request 0
+                // and :
+                // - we have no allocation done, just return
+                // - we have allocation but no element, free allocation and reset internal state
+                if (count == 0)
+                {
+                    if (max_slot_count_ == 0)
+                        return;
+                    if (is_empty())
+                        reset_control_and_slot();
+                }
+
+                // We request 0 or more and we have allocation and elements
+                // bitor is a faster way of doing `max` here. We will round up to the next
+                // power-of-2-minus-1, so bitor is good enough.
+                usize max_count = compute_max_count(count | min_capacity_for_count(count));
+                if (count == 0 || max_count > max_slot_count_)
+                    resize(max_count);
+                return;
+            }
+
             [[nodiscard]]
             constexpr const_iterator find(const key_type &key) const noexcept
             {
@@ -1463,9 +1486,10 @@ namespace hud
             [[nodiscard]] constexpr usize insert_no_construct(u64 h1, u8 h2) noexcept
             {
                 // If we reach the load factor grow the table and retrieves the new slot, else use the given slot
+                // TODO : check rehash_and_grow_if_necessary and implement the SQuash DELETED branch
                 if (free_slot_before_grow() == 0)
                 {
-                    grow_capacity(next_capacity());
+                    resize(next_capacity());
                 }
 
                 // Find the first empty of deleted slot that can be used for this h1 hash
@@ -1478,9 +1502,9 @@ namespace hud
                 return slot_index;
             }
 
-            constexpr void grow_capacity(usize new_max_slot_count) noexcept
+            constexpr void resize(usize new_max_slot_count) noexcept
             {
-                hud::check(new_max_slot_count > max_slot_count_ && "Grow need a bigger value");
+                // hud::check(new_max_slot_count > max_slot_count_ && "Grow need a bigger value");
                 hud::check(hud::bits::is_valid_power_of_two_mask(max_slot_count_) && "Not a mask");
 
                 // Create the buffer with control and slots
@@ -1622,6 +1646,18 @@ namespace hud
                                                                           capacity - capacity / 8;
             }
 
+            /** Compute the minimum capacity needed for the given `count` element that respect the load factor */
+            [[nodiscard]] constexpr usize min_capacity_for_count(usize count) noexcept
+            {
+                // `count*8/7`
+                if (group_type::SLOT_PER_GROUP == 8 && count == 7)
+                {
+                    // x+(x-1)/7 does not work when x==7.
+                    return 8;
+                }
+                return count + static_cast<usize>((static_cast<i64>(count) - 1) / 7);
+            }
+
             [[nodiscard]]
             constexpr control_type *control_ptr_sentinel() const noexcept
             {

test/hashmap/hashmap_remove.cpp

@@ -8,10 +8,12 @@ namespace hud_test
         using super = hud_test::non_bitwise_type;
         using super::super;
 
+#if defined(HD_COMPILER_GCC)
         virtual constexpr ~collided_key() noexcept
         {
             super::~super();
         }
+#endif
     };
 } // namespace hud_test
 

test/hashmap/hashmap_reserve.cpp

@@ -55,10 +55,6 @@ GTEST_TEST(hashmap, reserve_empty_to_size_allocate_only)
         reserve_ok &= map.slack() >= 0;
         reserve_ok &= (map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1));
         reserve_ok &= map.allocator().free_count() == 0;
-        for (const auto &[key, value] : map)
-        {
-            reserve_ok = false;
-        }
         return reserve_ok;
     };