Start adding SSE2 group for hashset

Julian LALU · Julian LALU · commit 17a5ebd9d415 · 2025-09-03T18:04:36.000+02:00
diff --git a/interface/core/compiler_defines.h b/interface/core/compiler_defines.h
@@ -44,6 +44,19 @@ __arm__. If defined, you can further check:
 __powerpc64__
 __aarch64__
 
+---- To check SIMD
+MSVC :
+AVX-512         __AVX512F__
+AVX2            __AVX2__
+AVX             __AVX__
+SSE2            _M_IX86_FP == 2
+SSE             _M_IX86_FP == 1
+Clang :
+AVX-512         __AVX512F__
+AVX2            __AVX2__
+AVX             __AVX__
+SSE2            __SSE__
+SSE             __SSE2__
 */
 
 /** Detect target OS */
@@ -180,4 +193,38 @@ static_assert(sizeof(void *) == 8, "HD_TARGET_64_BITS is defined but size of poi
     #error Target should be 32 bits or 64 bits
 #endif
 
+/**  Detect SIMD
+- MSVC :
+AVX-512         __AVX512F__
+AVX2            __AVX2__
+AVX             __AVX__
+SSE2            _M_IX86_FP == 2
+SSE             _M_IX86_FP == 1
+- Clang, GCC:
+AVX-512         __AVX512F__
+AVX2            __AVX2__
+AVX             __AVX__
+SSE2            __SSE2__
+SSE             __SSE__
+*/
+#if defined(__AVX512F__)
+    #define HD_AVX512
+#endif
+#if defined(__AVX2__)
+    #define HD_AVX2
+#endif
+#if defined(__AVX__)
+    #define HD_AVX
+#endif
+#if defined(__SSE__) || (_M_IX86_FP == 2)
+    #define HD_SSE2
+#endif
+#if defined(__SSE__) || (_M_IX86_FP == 1)
+    #define HD_SSE
+#endif
+
+// #if defined(__SSSE3__)
+//     #define HD_SSSE3
+// #endif
+
 #endif // HD_INC_CORE_COMPILER_DEFINES_H
diff --git a/interface/core/containers/hashset.h b/interface/core/containers/hashset.h
@@ -17,6 +17,9 @@
 #include "../traits/conditional.h"
 #include "compressed_tuple.h"
 
+#if defined(HD_SSSE3)
+    #include <tmmintrin.h>
+#endif
 // TODO:
 // Move common to a common class that contains max_slot_count_, count_, control_ptr_, slot_ptr_ and free_slot_before_grow_
 // Hashset
@@ -362,7 +365,154 @@ namespace hud
         static constexpr control_type empty_byte = 0b10000000;    // The slot is empty (0x80)
         static constexpr control_type deleted_byte = 0b11111110;  // The slot is deleted (0xFE)
         static constexpr control_type sentinel_byte = 0b11111111; // The slot is a sentinel, A sentinel is a special caracter that mark the end of the control for iteration (0xFF)
+#if defined(HD_SSE2)
+        struct sse2_group
+        {
+            static constexpr usize SLOT_PER_GROUP = 16;
+
+            struct mask
+            {
+                constexpr mask(u16 mask_value) noexcept
+                    : mask_value_ {mask_value}
+                {
+                }
+
+                [[nodiscard]]
+                friend constexpr bool operator==(const mask &a, const mask &b) noexcept
+                {
+                    return a.mask_value_ == b.mask_value_;
+                }
+
+                [[nodiscard]]
+                friend constexpr bool operator!=(const mask &a, const mask &b) noexcept
+                {
+                    return !(a == b);
+                }
+
+                /** Retrieves the index of the first non null byte set. 0 otherwise. */
+                [[nodiscard]] constexpr u32 first_non_null_index() const noexcept
+                {
+                    // Get number of trailing zero to get the insert offset of the byte
+                    return hud::bits::trailing_zeros(mask_value_);
+                }
+
+                [[nodiscard]]
+                constexpr operator u16() const noexcept
+                {
+                    return mask_value_;
+                }
+
+            protected:
+                u16 mask_value_;
+            };
+
+            struct empty_mask
+                : mask
+            {
+                using mask::mask;
+
+                [[nodiscard]] constexpr bool has_empty_slot() const noexcept
+                {
+                    return *this;
+                }
+
+                [[nodiscard]] constexpr u32 first_empty_index() const noexcept
+                {
+                    return first_non_null_index();
+                }
+
+                [[nodiscard]] constexpr u32 trailing_zeros() const noexcept
+                {
+                    return hud::bits::trailing_zeros(mask_value_);
+                }
+
+                [[nodiscard]] constexpr u32 leading_zeros() const noexcept
+                {
+                    return hud::bits::leading_zeros(mask_value_);
+                }
+            };
 
+            struct empty_or_deleted_mask
+                : mask
+            {
+                using mask::mask;
+
+                [[nodiscard]] constexpr bool has_empty_or_deleted_slot() const noexcept
+                {
+                    return *this;
+                }
+
+                [[nodiscard]] constexpr u32 first_empty_or_deleted_index() const noexcept
+                {
+                    return first_non_null_index();
+                }
+            };
+
+            struct full_mask
+                : mask
+            {
+                using mask::mask;
+
+                [[nodiscard]] constexpr bool has_full_slot() const noexcept
+                {
+                    return *this;
+                }
+
+                [[nodiscard]] constexpr u32 first_full_index() const noexcept
+                {
+                    return first_non_null_index();
+                }
+            };
+
+            /** Load a 16 bytes control into the group. */
+            constexpr sse2_group(const control_type *control) noexcept
+                : value_(hud::memory::unaligned_load128(control))
+            {
+            }
+
+            /**Retrieve a mask where H2 matching control byte have value 0x80 and non matching have value 0x00. */
+            mask match(u8 h2_hash) const noexcept
+            {
+                __m128i match = _mm_set1_epi8(static_cast<char>(h2_hash));
+                return mask(_mm_movemask_epi8(_mm_cmpeq_epi8(match, value_)));
+            }
+
+            /** Retrieve a mask where empty control bytes have value 0x80 and others have value 0x00. */
+            empty_mask mask_of_empty_slot() const noexcept
+            {
+    #if defined(HD_SSSE3)
+                return _mm_movemask_epi8(_mm_sign_epi8(value_, value_));
+    #else
+                __m128i match = _mm_set1_epi8(static_cast<char>(empty_byte));
+                return _mm_movemask_epi8(_mm_cmpeq_epi8(match, value_));
+    #endif
+            };
+
+            /** Retrieve a mask where empty and deleted control bytes have value 0x80 and others have value 0x00. */
+            empty_or_deleted_mask mask_of_empty_or_deleted_slot() const noexcept
+            {
+                __m128i special = _mm_set1_epi8(static_cast<char>(sentinel_byte));
+                return _mm_movemask_epi8(_mm_cmpgt_epi8(special, value_));
+            }
+
+            /** Retrieve a mask where full control bytes have value 0x80 and others have value 0x00. */
+            full_mask mask_of_full_slot() const noexcept
+            {
+                return _mm_movemask_epi8(value_) ^ 0xffff;
+            }
+
+            u32 count_leading_empty_or_deleted() const noexcept
+            {
+                auto special = _mm_set1_epi8(static_cast<char>(sentinel_byte));
+                u32 mask = _mm_movemask_epi8(_mm_cmpgt_epi8(special, value_)) + 1;
+                return hud::bits::trailing_zeros(mask);
+            }
+
+        private:
+            /** The 16 bytes value of the group. */
+            __m128i value_;
+        };
+#endif
         /** Portable group used to analyze a group. */
         struct portable_group
         {
@@ -594,8 +744,6 @@ namespace hud
                 // kDeleted. We lower all other bits and count number of trailing zeros.
                 constexpr uint64_t bits {0x0101010101010101ULL};
                 return static_cast<u32>(hud::bits::trailing_zeros((value_ | ~(value_ >> 7)) & bits) >> 3);
-                // return static_cast<u32>(countr_zero((ctrl | ~(ctrl >> 7)) & bits) >> 3);
-                // return 0;
             }
 
         private:
diff --git a/interface/core/memory/memory.h b/interface/core/memory/memory.h
@@ -37,6 +37,10 @@
 #include "../templates/move.h"
 #include "../templates/forward.h"
 
+#if defined(HD_SSE2)
+    #include <emmintrin.h>
+#endif
+
 namespace hud
 {
     struct memory
@@ -1104,6 +1108,22 @@ namespace hud
             return hud::bit_cast<u64>(result);
         }
 
+#if defined(HD_SSE2)
+        /** Load 128 bits value and return it. */
+        [[nodiscard]] static constexpr __m128i unaligned_load128(const i8 *buffer) noexcept
+        {
+            if (hud::is_constant_evaluated())
+            {
+                i8 result[sizeof(__m128i)];
+                copy_memory(result, buffer, sizeof(__m128i));
+                return hud::bit_cast<__m128i>(result);
+            }
+            else
+            {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i *>(buffer));
+            }
+        }
+#endif
         /**
          * Call constructor of type.
          * @tparam type_t Type to construct
diff --git a/test/hashmap/hashmap_misc.cpp b/test/hashmap/hashmap_misc.cpp
@@ -10,80 +10,6 @@ GTEST_TEST(hashmap, hashmap_value_type_is_correct)
     hud_assert_true((hud::is_same_v<const i32, hud::hashmap<i64, const i32>::value_type>));
 }
 
-GTEST_TEST(hashmap, metadata)
-{
-    // Testing metadata byte filtering
-    using control_type = hud::details::hashset::control_type;
-    hud_assert_true(hud::details::hashset::control::is_byte_empty(hud::details::hashset::empty_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_empty(hud::details::hashset::deleted_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_empty(hud::details::hashset::sentinel_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_empty(0x7F));
-
-    hud_assert_false(hud::details::hashset::control::is_byte_deleted(hud::details::hashset::empty_byte));
-    hud_assert_true(hud::details::hashset::control::is_byte_deleted(hud::details::hashset::deleted_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_deleted(hud::details::hashset::sentinel_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_deleted(0x7F));
-
-    hud_assert_true(hud::details::hashset::control::is_byte_empty_or_deleted(hud::details::hashset::empty_byte));
-    hud_assert_true(hud::details::hashset::control::is_byte_empty_or_deleted(hud::details::hashset::deleted_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_empty_or_deleted(hud::details::hashset::sentinel_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_empty_or_deleted(0x7F));
-
-    hud_assert_false(hud::details::hashset::control::is_byte_full(hud::details::hashset::empty_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_full(hud::details::hashset::deleted_byte));
-    hud_assert_false(hud::details::hashset::control::is_byte_full(hud::details::hashset::sentinel_byte));
-    hud_assert_true(hud::details::hashset::control::is_byte_full(0x7F));
-
-    // Testing metadata group
-    using group_type = hud::details::hashset::group_type;
-    using mask_type = group_type::mask;
-    using mask_empty_type = group_type::empty_mask;
-    using mask_empty_or_deleted_type = group_type::empty_or_deleted_mask;
-    using mask_full_type = group_type::full_mask;
-
-    u64 group_value = 0x80FEFF7F80FEFF7F;
-    group_type g {reinterpret_cast<control_type *>(&group_value)};
-    hud_assert_eq(g.match(0x7F), mask_type {0x0000008000000080});
-    hud_assert_eq(g.mask_of_empty_or_deleted_slot(), mask_empty_or_deleted_type {0x8080000080800000});
-    hud_assert_eq(g.mask_of_empty_slot(), mask_empty_type {0x8000000080000000});
-    hud_assert_eq(g.mask_of_full_slot(), mask_full_type {0x0000008000000080});
-
-    // Test group at index
-    // empty (0x80), deleted (0xFE), sentinel (0xFF)
-    u64 two_group[2] = {0x7F00806DFE002A6D, 0x807B00800000FEFF};
-    control_type *metadata_ptr(reinterpret_cast<control_type *>(&two_group));
-    group_type g0 {metadata_ptr};
-    // Read first group
-    hud_assert_eq(g0.match(0x7F), mask_type {0x8000000000000000});
-    hud_assert_eq(g0.match(0x2A), mask_type {0x0000000000008000});
-    hud_assert_eq(g0.match(0x6D), mask_type {0x0000008000000080});
-    hud_assert_eq(g0.mask_of_empty_or_deleted_slot(), mask_empty_or_deleted_type {0x0000800080000000});
-    hud_assert_eq(g0.mask_of_empty_slot(), mask_empty_type {0x0000800000000000});
-    hud_assert_eq(g0.mask_of_full_slot(), mask_full_type {0x8080008000808080});
-
-    group_type g1 {metadata_ptr + group_type::SLOT_PER_GROUP * 1};
-    // Read second group
-    hud_assert_eq(g1.match(0x7B), mask_type {0x0080000000000000});
-    hud_assert_eq(g1.mask_of_empty_or_deleted_slot(), mask_empty_or_deleted_type {0x8000008000008000});
-    hud_assert_eq(g1.mask_of_empty_slot(), mask_empty_type {0x8000008000000000});
-    hud_assert_eq(g1.mask_of_full_slot(), mask_full_type {0x0080800080800000});
-
-    // Test find with group and iteration
-    // Find the 2 indices of 0x6D in the group and iterate over it
-    // Expect to have index 0 and 4 in the group 0x7F00806DFE002A6D
-    group_type::mask h2_match_mask = g0.match(0x6D);
-    u32 indices[2] = {hud::u32_max, hud::u32_max};
-    u32 current_index = 0;
-    for (u32 value : h2_match_mask)
-    {
-        hud_assert_ne(current_index, 2);
-        indices[current_index] = value;
-        ++current_index;
-    }
-    hud_assert_eq(indices[0], 0);
-    hud_assert_eq(indices[1], 4);
-}
-
 GTEST_TEST(hashmap, count_return_count_of_element)
 {
     using type = usize;
diff --git a/test/hashset/hashset_misc.cpp b/test/hashset/hashset_misc.cpp
