Update hashmap

Author: Julian LALU

interface/core/containers/hashmap.h

@@ -37,7 +37,14 @@ namespace hud
         {
         };
 
+        template<typename slot_t>
+        struct default_allocator
+            : hud::heap_allocator
+        {
+        };
+
         using control_type = u8;
+
         static constexpr control_type control_empty = 0b10000000;    // The slot is empty
         static constexpr control_type control_deleted = 0b11111110;  // The slot is deleted
         static constexpr control_type control_sentinel = 0b11111111; // The slot is a sentinel, A sentinel is a special caracter that mark the end of the control for iteration
@@ -53,23 +60,56 @@ namespace hud
             using value_type = typename hud::pair<key_t, value_t>::second_type;
         };
 
+        struct group_portable_iterator
+        {
+            constexpr group_portable_iterator(u64 mask) noexcept
+                : mask_(mask)
+            {
+            }
+
+            [[nodiscard]] constexpr explicit operator bool() const noexcept
+            {
+                return mask_ != 0;
+            }
+
+            [[nodiscard]] constexpr u32 insertion_byte_offset() const noexcept
+            {
+                // Get number of trailing zero and divide it by 8 (>>3) to get the insert offset of the byte
+                return hud::bits::trailing_zero(mask_) >> 3;
+            }
+
+            u64 mask_;
+        };
+
         struct group_portable
         {
+            using iterator_type = group_portable_iterator;
             static constexpr u64 slot_per_group_ = 8;
 
             constexpr group_portable(const control_type *control) noexcept
                 : value_(hud::memory::unaligned_load64(static_cast<const u8 *>(control)))
             {
             }
 
-            u64 match(u8 h2_hash)
+            constexpr iterator_type match(u8 h2_hash) const noexcept
             {
-                return hud::bits::has_zero_byte(hud::bits::has_value_byte(value_, h2_hash));
+                return iterator_type {hud::bits::has_zero_byte(hud::bits::has_value_byte(value_, h2_hash))};
             }
 
-            u64 mask_of_empty_slot()
+            constexpr iterator_type mask_of_empty_slot() const noexcept
             {
-                return hud::bits::has_zero_byte(hud::bits::has_value_byte(value_, control_empty));
+                return hud::bits::has_value_byte(value_, control_empty);
+            }
+
+            [[nodiscard]] constexpr bool
+            operator==(const group_portable &other) const noexcept
+            {
+                return value_ == other.value_;
+            }
+
+            [[nodiscard]] constexpr bool operator!=(const group_portable &other) const noexcept
+            {
+                return value_ == other.value_;
             }
 
         private:
@@ -86,37 +126,39 @@ namespace hud
             {
                 hud::check(((mask + 1) & mask) == 0 && "not a mask");
                 mask_ = mask;
-                offset_ = h1_hash & mask_;
+                byte_offset_ = h1_hash & mask_;
             }
 
-            u64 offset() const
+            u64 byte_offset() const
             {
-                return offset_;
+                return byte_offset_;
             }
 
-            u64 offset(u64 i) const
+            u64 byte_offset(u64 i) const
             {
-                return (offset_ + i) & mask_;
+                return (byte_offset_ + i) & mask_;
             }
 
             void next_group()
             {
+                // Next group index
                 index_ += group::slot_per_group_;
-                offset_ += index_;
-                offset_ &= mask_;
+                byte_offset_ += index_;
+                byte_offset_ &= mask_;
             }
 
             // 0-based probe index, a multiple of `Width`.
-            u64 index_() const
+            u64 index() const
             {
                 return index_;
             }
 
         private:
             /** Mask used to iterate over. */
             u64 mask_;
-            /** */
-            u64 offset_;
+            /** Byte offset */
+            u64 byte_offset_;
+
             u64 index_ {0};
         };
 
@@ -172,7 +214,7 @@ namespace hud
 
         private:
             // The current control we are iterating. For the moment set to the global init control
-            control_type *control_ {const_cast<control_type *>(&EMPTY_GROUP[32])};
+            control_type *control_;
             // The current slot we are iterating. Keep uninitialized.
             value_type *slot_;
         };
@@ -207,22 +249,71 @@ namespace hud
             using value_type = typename slot_type::value_type;
             /** Type of the hash function. */
             using hasher_type = hasher_t;
-            /** Type of the iterator */
-            using iterator = hud::details::hashmap::iterator<slot_type>;
+            /** Type of the iterator/ */
+            using iterator_type = hud::details::hashmap::iterator<slot_type>;
+            /**  Type of the allocator. */
+            using allocator_type = allocator_t;
+            /** The type of allocation done by the allocator. */
+            using memory_allocation_type = typename allocator_type::template memory_allocation_type<slot_type>;
 
         public:
             constexpr hashmap_impl() noexcept
-                : control_(const_cast<control_type *>(&EMPTY_GROUP[32])) // Point to the sentinel in the empty group, const_cast is ok, EMPTY_GROUP is used only when the table is empty
+                : control_(const_cast<control_type *>(&EMPTY_GROUP[16])) // Point to the sentinel in the empty group, const_cast is ok, EMPTY_GROUP is used only when the table is empty
             {
             }
 
-            constexpr hud::optional<iterator> insert(const key_type &key, const value_type &value) noexcept
+            constexpr hud::optional<iterator_type> insert(const key_type &key, const value_type &value) noexcept
             {
                 return find_or_prepare_insert(key);
             }
 
+            constexpr void resize(usize new_max_slot_count) noexcept
+            {
+                max_slot_count_ = new_max_slot_count;
+
+                // Perform allocation of the buffer
+                // |-------------------|----------------/
+                // | control metadata  | Aligned slots  /
+                // |-------------------|----------------/
+                constexpr const usize num_cloned_bytes = group::slot_per_group_ - 1;
+                const usize control_size = max_count() + 1 + num_cloned_bytes;
+                // Compute the control_size that is a multiple of the slot_type alignement
+                // We are shure to allocate enough memory for control_size and we ensure to be align on alignof(slot_type) after this allocation size
+                // control_size is multiple of sizeof(slot_type)
+                const uptr aligned_control_size = hud::memory::align_address(control_size, sizeof(slot_type));
+                const usize aligned_allocation_size = aligned_control_size + new_max_slot_count * sizeof(slot_type);
+
+                // Allocate the buffer that will contains control metadata and aligned slots
+                memory_allocation_type allocation = allocator_.template allocate<slot_type>(aligned_allocation_size);
+
+                // Save control metadata and slot pointers
+                control_ = hud::bit_cast<control_type *>(allocation.data());
+                slot_type *slot_ptr = hud::bit_cast<slot_type *>(control_ + aligned_control_size);
+                hud::check(hud::memory::is_pointer_aligned(slot_ptr, alignof(slot_type)));
+
+                // Update number of slot we should put into the table before a resizing rehash
+                growth_left_ = max_growth_left() - count();
+
+                // Reset control metadata
+                hud::memory::set(control_, control_empty, control_size);
+                control_[max_slot_count_] = control_sentinel;
+
+                // 
+                if (old)
+            }
+
+            [[nodiscard]] constexpr usize max_count() const noexcept
+            {
+                return max_slot_count_;
+            }
+
+            [[nodiscard]] constexpr usize count() const noexcept
+            {
+                return count_;
+            }
+
         private:
-            constexpr hud::optional<iterator> find_or_prepare_insert(const key_type &key)
+            constexpr hud::optional<iterator_type> find_or_prepare_insert(const key_type &key)
             {
                 // TODO: prefetch control bloc
                 // Hash the key
@@ -231,44 +322,68 @@ namespace hud
                 const control_type *control = control_;
                 while (true)
                 {
-                    group g {control + probe.offset()};
+                    group g {control + probe.byte_offset()};
                     // for (u32 i : g.match(H2(hash)))
                     // {
                     // }
-                    u64 mask_of_empty_slot = g.mask_of_empty_slot();
-                    if (mask_of_empty_slot != 0) [[likely]]
+                    group::iterator_type mask_of_empty_slot = g.mask_of_empty_slot();
+                    if (mask_of_empty_slot) [[likely]]
                     {
-                        u64 insert_offset = hud::bits::trailing_zero(mask_of_empty_slot);
-                        u64 target = probe.offset(insert_offset);
+                        u64 insertion_byte_offset = mask_of_empty_slot.insertion_byte_offset();
+                        u64 target = probe.byte_offset(insertion_byte_offset);
                         prepare_insert(hash, target, probe.index());
                     }
                 }
                 return hud::nullopt;
             }
 
-            u64 prepare_insert(u64 hash, u64 target, )
+            constexpr u64 prepare_insert(u64 hash, u64 target, u64 probe_lenght)
             {
                 if (growth_left_ == 0)
                 {
-                    const usize old_capacity = max_slot_count_;
+                    // const usize old_capacity = max_count();
                     rehash_and_grow_if_necessary();
                 }
+                return 0;
             }
 
-            void rehash_and_grow_if_necessary()
+            constexpr void rehash_and_grow_if_necessary()
             {
-                const usize cap = max_slot_count_;
+                const usize capacity = max_count();
 
                 // Rehash in place if the current size is <= 25/32 of capacity.
-                if (cap > group::slot_per_group_ && count_ * uint64_t {32} <= cap * uint64_t {25})
+                if (capacity > group::slot_per_group_ && count_ * uint64_t {32} <= capacity * uint64_t {25})
                 {
                 }
                 else
                 {
-                    resize(NextCapacity(cap));
+                    resize(next_capacity(capacity));
                 }
             }
 
+            [[nodiscard]] constexpr usize next_capacity(usize capacity) const noexcept
+            {
+                return capacity * 2 + 1;
+            }
+
+            /**
+             * Compute the maximum number of slots we should put into the table before a resizing rehash.
+             * Subtract the returned value with the number of slots `count()` to obtains the number of slots we can currently before a resizing rehash.
+             */
+            [[nodiscard]] constexpr usize max_growth_left() noexcept
+            {
+                // Current load factor is 7/8, this means we can resize when 7/8 slots are occupied
+                // A special case appear when group are 8 bytes width and `max_count()` is 7 : 7−7/8=7, in this case, we return 6
+                //
+                // | Capacity (capacity) | capacity - capacity / 8 | result (max_growth_left) |
+                // |  7 (special case)   |            -            |             6            |
+                // |          8          |       8−8/8             |             7            |
+                // |         16          |      16−16/8            |            14            |
+                // |         32          |      32−32/8            |            28            |
+                // |         64          |      64−64/8            |            56            |
+                return group::slot_per_group_ == 8 && max_count() == 7 ? 6 : max_count() - max_count() / 8;
+            }
+
         private:
             /** The max slot count of the hashmap. */
             usize max_slot_count_ {0};
@@ -282,8 +397,11 @@ namespace hud
             /** Pointer to the slot segment. */
             value_type *slots_;
 
-            /** growth left elements. */
+            /** Number of slot we should put into the table before a resizing rehash. */
             usize growth_left_ {0};
+
+            /** The allocator. */
+            allocator_type allocator_;
         };
 
     } // namespace details::hashmap
@@ -293,10 +411,9 @@ namespace hud
         typename value_t,
         typename hasher_t = details::hashmap::default_hasher<key_t>,
         typename key_equal_t = details::hashmap::default_equal<key_t>,
-        typename allocator_t = heap_allocator>
+        typename allocator_t = details::hashmap::default_allocator<details::hashmap::slot<key_t, value_t>>>
     class hashmap
         : details::hashmap::hashmap_impl<details::hashmap::slot<key_t, value_t>, hasher_t, key_equal_t, allocator_t>
-
     {
     private:
         using super = details::hashmap::hashmap_impl<details::hashmap::slot<key_t, value_t>, hasher_t, key_equal_t, allocator_t>;

interface/core/containers/hashset.h

@@ -20,7 +20,7 @@ namespace hud
         typename value_t,
         typename hasher_t = details::hashmap::default_hasher<value_t>,
         typename key_equal_t = details::hashmap::default_equal<value_t>,
-        typename allocator_t = heap_allocator>
+        typename allocator_t = details::hashmap::default_allocator<value_t>>
     class hashset
         : details::hashmap::hashmap_impl<details::hashset::slot<value_t>, hasher_t, key_equal_t, allocator_t>
     {

interface/core/os_common/bits.h

@@ -103,8 +103,8 @@ namespace hud::os::common
 
         [[nodiscard]] static constexpr u64 trailing_zero(u64 value) noexcept
         {
-            u64 c = 64;           // c sera le nombre de bits zéro à droite
-            value &= -i64(value); // Mask les bits de poids faible avec l'opération de complément à 2
+            u64 c = 64; // c will be the number of zero bits on the right
+            value &= -i64(value);
             if (value)
                 c--;
             if (value & 0x00000000FFFFFFFFu)

interface/core/os_linux/uuid.h

@@ -29,10 +29,10 @@ namespace hud::os::linux
 
             // 1. Generate 16 random bytes (=128 bits)
             alignas(16) u8 bytes[16];
-            i32 bytes_coun_copied = getrandom(bytes, sizeof(bytes), GRND_RANDOM);
+            i32 bytes_count_copied = getrandom(bytes, sizeof(bytes), GRND_RANDOM);
 
             // LCOV_EXCL_START ( Supposed never failed, else alternative is to read in /dev/{u}random )
-            if (bytes_coun_copied != sizeof(bytes))
+            if (bytes_count_copied != sizeof(bytes)) [[unlikely]]
             {
                 return false;
             }