usearch 2.15.3 → 2.16.0

package/simsimd/include/simsimd/binary.h

@@ -9,8 +9,8 @@
  *  - Jaccard similarity (Tanimoto coefficient)
  *
  *  For hardware architectures:
- *  - Arm (NEON, SVE)
- *  - x86 (AVX2, AVX512)
+ *  - Arm: NEON, SVE
+ *  - x86: Haswell, Ice Lake
  *
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
@@ -60,52 +60,86 @@ SIMSIMD_PUBLIC unsigned char simsimd_popcount_b8(simsimd_b8_t x) {
     return lookup_table[x];
 }
 
-SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                              simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                              simsimd_distance_t *result) {
     simsimd_i32_t differences = 0;
-    for (simsimd_size_t i = 0; i != n_words; ++i)
-        differences += simsimd_popcount_b8(a[i] ^ b[i]);
+    for (simsimd_size_t i = 0; i != n_words; ++i) differences += simsimd_popcount_b8(a[i] ^ b[i]);
     *result = differences;
 }
 
-SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                              simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                              simsimd_distance_t *result) {
     simsimd_i32_t intersection = 0, union_ = 0;
     for (simsimd_size_t i = 0; i != n_words; ++i)
         intersection += simsimd_popcount_b8(a[i] & b[i]), union_ += simsimd_popcount_b8(a[i] | b[i]);
     *result = (union_ != 0) ? 1 - (simsimd_f64_t)intersection / (simsimd_f64_t)union_ : 1;
 }
 
-#if SIMSIMD_TARGET_ARM
+#if _SIMSIMD_TARGET_ARM
 #if SIMSIMD_TARGET_NEON
 #pragma GCC push_options
 #pragma GCC target("arch=armv8.2-a+simd")
 #pragma clang attribute push(__attribute__((target("arch=armv8.2-a+simd"))), apply_to = function)
 
-SIMSIMD_PUBLIC void simsimd_hamming_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                            simsimd_distance_t* result) {
+SIMSIMD_INTERNAL simsimd_u32_t _simsimd_reduce_u8x16_neon(uint8x16_t vec) {
+    // Split the vector into two halves and widen to `uint16x8_t`
+    uint16x8_t low_half = vmovl_u8(vget_low_u8(vec));   // widen lower 8 elements
+    uint16x8_t high_half = vmovl_u8(vget_high_u8(vec)); // widen upper 8 elements
+
+    // Sum the widened halves
+    uint16x8_t sum16 = vaddq_u16(low_half, high_half);
+
+    // Now reduce the `uint16x8_t` to a single `uint32_t`
+    uint32x4_t sum32 = vpaddlq_u16(sum16);  // pairwise add into 32-bit integers
+    uint64x2_t sum64 = vpaddlq_u32(sum32);  // pairwise add into 64-bit integers
+    uint32_t final_sum = vaddvq_u64(sum64); // final horizontal add to 32-bit result
+    return final_sum;
+}
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_neon(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                            simsimd_distance_t *result) {
     simsimd_i32_t differences = 0;
     simsimd_size_t i = 0;
-    for (; i + 16 <= n_words; i += 16) {
-        uint8x16_t a_first = vld1q_u8(a + i);
-        uint8x16_t b_first = vld1q_u8(b + i);
-        differences += vaddvq_u8(vcntq_u8(veorq_u8(a_first, b_first)));
+    // In each 8-bit word we may have up to 8 differences.
+    // So for up-to 31 cycles (31 * 16 = 496 word-dimensions = 3968 bits)
+    // we can aggregate the differences into a `uint8x16_t` vector,
+    // where each component will be up-to 255.
+    while (i + 16 <= n_words) {
+        uint8x16_t differences_cycle_vec = vdupq_n_u8(0);
+        for (simsimd_size_t cycle = 0; cycle < 31 && i + 16 <= n_words; ++cycle, i += 16) {
+            uint8x16_t a_vec = vld1q_u8(a + i);
+            uint8x16_t b_vec = vld1q_u8(b + i);
+            uint8x16_t xor_count_vec = vcntq_u8(veorq_u8(a_vec, b_vec));
+            differences_cycle_vec = vaddq_u8(differences_cycle_vec, xor_count_vec);
+        }
+        differences += _simsimd_reduce_u8x16_neon(differences_cycle_vec);
     }
     // Handle the tail
-    for (; i != n_words; ++i)
-        differences += simsimd_popcount_b8(a[i] ^ b[i]);
+    for (; i != n_words; ++i) differences += simsimd_popcount_b8(a[i] ^ b[i]);
     *result = differences;
 }
 
-SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                            simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                            simsimd_distance_t *result) {
     simsimd_i32_t intersection = 0, union_ = 0;
     simsimd_size_t i = 0;
-    for (; i + 16 <= n_words; i += 16) {
-        uint8x16_t a_first = vld1q_u8(a + i);
-        uint8x16_t b_first = vld1q_u8(b + i);
-        intersection += vaddvq_u8(vcntq_u8(vandq_u8(a_first, b_first)));
-        union_ += vaddvq_u8(vcntq_u8(vorrq_u8(a_first, b_first)));
+    // In each 8-bit word we may have up to 8 intersections/unions.
+    // So for up-to 31 cycles (31 * 16 = 496 word-dimensions = 3968 bits)
+    // we can aggregate the intersections/unions into a `uint8x16_t` vector,
+    // where each component will be up-to 255.
+    while (i + 16 <= n_words) {
+        uint8x16_t intersections_cycle_vec = vdupq_n_u8(0);
+        uint8x16_t unions_cycle_vec = vdupq_n_u8(0);
+        for (simsimd_size_t cycle = 0; cycle < 31 && i + 16 <= n_words; ++cycle, i += 16) {
+            uint8x16_t a_vec = vld1q_u8(a + i);
+            uint8x16_t b_vec = vld1q_u8(b + i);
+            uint8x16_t and_count_vec = vcntq_u8(vandq_u8(a_vec, b_vec));
+            uint8x16_t or_count_vec = vcntq_u8(vorrq_u8(a_vec, b_vec));
+            intersections_cycle_vec = vaddq_u8(intersections_cycle_vec, and_count_vec);
+            unions_cycle_vec = vaddq_u8(unions_cycle_vec, or_count_vec);
+        }
+        intersection += _simsimd_reduce_u8x16_neon(intersections_cycle_vec);
+        union_ += _simsimd_reduce_u8x16_neon(unions_cycle_vec);
     }
     // Handle the tail
     for (; i != n_words; ++i)
@@ -122,97 +156,274 @@ SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const* a, simsimd_b8_t
 #pragma GCC target("arch=armv8.2-a+sve")
 #pragma clang attribute push(__attribute__((target("arch=armv8.2-a+sve"))), apply_to = function)
 
-SIMSIMD_PUBLIC void simsimd_hamming_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                           simsimd_distance_t* result) {
-    simsimd_size_t i = 0;
+SIMSIMD_PUBLIC void simsimd_hamming_b8_sve(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                           simsimd_distance_t *result) {
+
+    // On very small register sizes, NEON is at least as fast as SVE.
+    simsimd_size_t const words_per_register = svcntb();
+    if (words_per_register <= 32) {
+        simsimd_hamming_b8_neon(a, b, n_words, result);
+        return;
+    }
+
+    // On larger register sizes, SVE is faster.
+    simsimd_size_t i = 0, cycle = 0;
     simsimd_i32_t differences = 0;
-    do {
-        svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
-        svuint8_t a_vec = svld1_u8(pg_vec, a + i);
-        svuint8_t b_vec = svld1_u8(pg_vec, b + i);
-        differences += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), sveor_u8_m(svptrue_b8(), a_vec, b_vec)));
-        i += svcntb();
-    } while (i < n_words);
+    svuint8_t differences_cycle_vec = svdup_n_u8(0);
+    svbool_t const all_vec = svptrue_b8();
+    while (i < n_words) {
+        do {
+            svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
+            svuint8_t a_vec = svld1_u8(pg_vec, a + i);
+            svuint8_t b_vec = svld1_u8(pg_vec, b + i);
+            differences_cycle_vec =
+                svadd_u8_z(all_vec, differences_cycle_vec, svcnt_u8_x(all_vec, sveor_u8_m(all_vec, a_vec, b_vec)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_words && cycle < 31);
+        differences += svaddv_u8(all_vec, differences_cycle_vec);
+        differences_cycle_vec = svdup_n_u8(0);
+        cycle = 0; // Reset the cycle counter.
+    }
+
     *result = differences;
 }
 
-SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                           simsimd_distance_t* result) {
-    simsimd_size_t i = 0;
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                           simsimd_distance_t *result) {
+
+    // On very small register sizes, NEON is at least as fast as SVE.
+    simsimd_size_t const words_per_register = svcntb();
+    if (words_per_register <= 32) {
+        simsimd_jaccard_b8_neon(a, b, n_words, result);
+        return;
+    }
+
+    // On larger register sizes, SVE is faster.
+    simsimd_size_t i = 0, cycle = 0;
     simsimd_i32_t intersection = 0, union_ = 0;
-    do {
-        svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
-        svuint8_t a_vec = svld1_u8(pg_vec, a + i);
-        svuint8_t b_vec = svld1_u8(pg_vec, b + i);
-        intersection += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), svand_u8_m(svptrue_b8(), a_vec, b_vec)));
-        union_ += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), svorr_u8_m(svptrue_b8(), a_vec, b_vec)));
-        i += svcntb();
-    } while (i < n_words);
+    svuint8_t intersection_cycle_vec = svdup_n_u8(0);
+    svuint8_t union_cycle_vec = svdup_n_u8(0);
+    svbool_t const all_vec = svptrue_b8();
+    while (i < n_words) {
+        do {
+            svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
+            svuint8_t a_vec = svld1_u8(pg_vec, a + i);
+            svuint8_t b_vec = svld1_u8(pg_vec, b + i);
+            intersection_cycle_vec =
+                svadd_u8_z(all_vec, intersection_cycle_vec, svcnt_u8_x(all_vec, svand_u8_m(all_vec, a_vec, b_vec)));
+            union_cycle_vec =
+                svadd_u8_z(all_vec, union_cycle_vec, svcnt_u8_x(all_vec, svorr_u8_m(all_vec, a_vec, b_vec)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_words && cycle < 31);
+        intersection += svaddv_u8(all_vec, intersection_cycle_vec);
+        intersection_cycle_vec = svdup_n_u8(0);
+        union_ += svaddv_u8(all_vec, union_cycle_vec);
+        union_cycle_vec = svdup_n_u8(0);
+        cycle = 0; // Reset the cycle counter.
+    }
+
     *result = (union_ != 0) ? 1 - (simsimd_f64_t)intersection / (simsimd_f64_t)union_ : 1;
 }
 
 #pragma clang attribute pop
 #pragma GCC pop_options
 #endif // SIMSIMD_TARGET_SVE
-#endif // SIMSIMD_TARGET_ARM
+#endif // _SIMSIMD_TARGET_ARM
 
-#if SIMSIMD_TARGET_X86
+#if _SIMSIMD_TARGET_X86
 #if SIMSIMD_TARGET_ICE
 #pragma GCC push_options
 #pragma GCC target("avx2", "avx512f", "avx512vl", "bmi2", "avx512bw", "avx512vpopcntdq")
-#pragma clang attribute push(__attribute__((target("avx2,avx512f,avx512vl,bmi2,avx512bw,avx512vpopcntdq"))),           \
+#pragma clang attribute push(__attribute__((target("avx2,avx512f,avx512vl,bmi2,avx512bw,avx512vpopcntdq"))), \
                              apply_to = function)
 
-SIMSIMD_PUBLIC void simsimd_hamming_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                           simsimd_distance_t* result) {
-    __m512i differences_vec = _mm512_setzero_si512();
-    __m512i a_vec, b_vec;
+SIMSIMD_PUBLIC void simsimd_hamming_b8_ice(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                           simsimd_distance_t *result) {
 
-simsimd_hamming_b8_ice_cycle:
-    if (n_words < 64) {
+    simsimd_size_t xor_count;
+    // It's harder to squeeze out performance from tiny representations, so we unroll the loops for binary metrics.
+    if (n_words <= 64) { // Up to 512 bits.
         __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
-        a_vec = _mm512_maskz_loadu_epi8(mask, a);
-        b_vec = _mm512_maskz_loadu_epi8(mask, b);
-        n_words = 0;
-    } else {
-        a_vec = _mm512_loadu_epi8(a);
-        b_vec = _mm512_loadu_epi8(b);
-        a += 64, b += 64, n_words -= 64;
+        __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a);
+        __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b);
+        __m512i xor_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a_vec, b_vec));
+        xor_count = _mm512_reduce_add_epi64(xor_count_vec);
     }
-    __m512i xor_vec = _mm512_xor_si512(a_vec, b_vec);
-    differences_vec = _mm512_add_epi64(differences_vec, _mm512_popcnt_epi64(xor_vec));
-    if (n_words)
-        goto simsimd_hamming_b8_ice_cycle;
-
-    simsimd_size_t differences = _mm512_reduce_add_epi64(differences_vec);
-    *result = differences;
+    else if (n_words <= 128) { // Up to 1024 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 64);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_maskz_loadu_epi8(mask, a + 64);
+        __m512i b2_vec = _mm512_maskz_loadu_epi8(mask, b + 64);
+        __m512i xor1_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a1_vec, b1_vec));
+        __m512i xor2_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a2_vec, b2_vec));
+        xor_count = _mm512_reduce_add_epi64(_mm512_add_epi64(xor2_count_vec, xor1_count_vec));
+    }
+    else if (n_words <= 196) { // Up to 1568 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 128);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_loadu_epi8(a + 64);
+        __m512i b2_vec = _mm512_loadu_epi8(b + 64);
+        __m512i a3_vec = _mm512_maskz_loadu_epi8(mask, a + 128);
+        __m512i b3_vec = _mm512_maskz_loadu_epi8(mask, b + 128);
+        __m512i xor1_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a1_vec, b1_vec));
+        __m512i xor2_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a2_vec, b2_vec));
+        __m512i xor3_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a3_vec, b3_vec));
+        xor_count =
+            _mm512_reduce_add_epi64(_mm512_add_epi64(xor3_count_vec, _mm512_add_epi64(xor2_count_vec, xor1_count_vec)));
+    }
+    else if (n_words <= 256) { // Up to 2048 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 192);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_loadu_epi8(a + 64);
+        __m512i b2_vec = _mm512_loadu_epi8(b + 64);
+        __m512i a3_vec = _mm512_loadu_epi8(a + 128);
+        __m512i b3_vec = _mm512_loadu_epi8(b + 128);
+        __m512i a4_vec = _mm512_maskz_loadu_epi8(mask, a + 192);
+        __m512i b4_vec = _mm512_maskz_loadu_epi8(mask, b + 192);
+        __m512i xor1_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a1_vec, b1_vec));
+        __m512i xor2_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a2_vec, b2_vec));
+        __m512i xor3_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a3_vec, b3_vec));
+        __m512i xor4_count_vec = _mm512_popcnt_epi64(_mm512_xor_si512(a4_vec, b4_vec));
+        xor_count = _mm512_reduce_add_epi64(_mm512_add_epi64(_mm512_add_epi64(xor4_count_vec, xor3_count_vec),
+                                                             _mm512_add_epi64(xor2_count_vec, xor1_count_vec)));
+    }
+    else {
+        __m512i xor_count_vec = _mm512_setzero_si512();
+        __m512i a_vec, b_vec;
+
+    simsimd_hamming_b8_ice_cycle:
+        if (n_words < 64) {
+            __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
+            a_vec = _mm512_maskz_loadu_epi8(mask, a);
+            b_vec = _mm512_maskz_loadu_epi8(mask, b);
+            n_words = 0;
+        }
+        else {
+            a_vec = _mm512_loadu_epi8(a);
+            b_vec = _mm512_loadu_epi8(b);
+            a += 64, b += 64, n_words -= 64;
+        }
+        __m512i xor_vec = _mm512_xor_si512(a_vec, b_vec);
+        xor_count_vec = _mm512_add_epi64(xor_count_vec, _mm512_popcnt_epi64(xor_vec));
+        if (n_words) goto simsimd_hamming_b8_ice_cycle;
+
+        xor_count = _mm512_reduce_add_epi64(xor_count_vec);
+    }
+    *result = xor_count;
 }
 
-SIMSIMD_PUBLIC void simsimd_jaccard_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                           simsimd_distance_t* result) {
-    __m512i intersection_vec = _mm512_setzero_si512(), union_vec = _mm512_setzero_si512();
-    __m512i a_vec, b_vec;
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_ice(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                           simsimd_distance_t *result) {
 
-simsimd_jaccard_b8_ice_cycle:
-    if (n_words < 64) {
+    simsimd_size_t intersection = 0, union_ = 0;
+    //? On such vectors we can clearly see that the CPU struggles to perform this many parallel
+    //? population counts, because the throughput of Jaccard and Hamming in this case starts to differ.
+    //? One optimization, aside from Harley-Seal transforms can be using "shuffles" for nibble-popcount
+    //? lookups, to utilize other ports on the CPU.
+    //? https://github.com/ashvardanian/SimSIMD/pull/138
+    //
+    //  - `_mm512_popcnt_epi64` maps to `VPOPCNTQ (ZMM, K, ZMM)`:
+    //      - On Ice Lake: 3 cycles latency, ports: 1*p5
+    //      - On Genoa: 2 cycles latency, ports: 1*FP01
+    //  - `_mm512_shuffle_epi8` maps to `VPSHUFB (ZMM, ZMM, ZMM)`:
+    //      - On Ice Lake: 1 cycles latency, ports: 1*p5
+    //      - On Genoa: 2 cycles latency, ports: 1*FP12
+    //
+    //  It's harder to squeeze out performance from tiny representations, so we unroll the loops for binary metrics.
+    if (n_words <= 64) { // Up to 512 bits.
         __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
-        a_vec = _mm512_maskz_loadu_epi8(mask, a);
-        b_vec = _mm512_maskz_loadu_epi8(mask, b);
-        n_words = 0;
-    } else {
-        a_vec = _mm512_loadu_epi8(a);
-        b_vec = _mm512_loadu_epi8(b);
-        a += 64, b += 64, n_words -= 64;
+        __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a);
+        __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b);
+        __m512i and_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a_vec, b_vec));
+        __m512i or_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a_vec, b_vec));
+        intersection = _mm512_reduce_add_epi64(and_count_vec);
+        union_ = _mm512_reduce_add_epi64(or_count_vec);
+    }
+    else if (n_words <= 128) { // Up to 1024 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 64);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_maskz_loadu_epi8(mask, a + 64);
+        __m512i b2_vec = _mm512_maskz_loadu_epi8(mask, b + 64);
+        __m512i and1_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a1_vec, b1_vec));
+        __m512i or1_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a1_vec, b1_vec));
+        __m512i and2_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a2_vec, b2_vec));
+        __m512i or2_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a2_vec, b2_vec));
+        intersection = _mm512_reduce_add_epi64(_mm512_add_epi64(and2_count_vec, and1_count_vec));
+        union_ = _mm512_reduce_add_epi64(_mm512_add_epi64(or2_count_vec, or1_count_vec));
+    }
+    else if (n_words <= 196) { // Up to 1568 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 128);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_loadu_epi8(a + 64);
+        __m512i b2_vec = _mm512_loadu_epi8(b + 64);
+        __m512i a3_vec = _mm512_maskz_loadu_epi8(mask, a + 128);
+        __m512i b3_vec = _mm512_maskz_loadu_epi8(mask, b + 128);
+        __m512i and1_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a1_vec, b1_vec));
+        __m512i or1_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a1_vec, b1_vec));
+        __m512i and2_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a2_vec, b2_vec));
+        __m512i or2_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a2_vec, b2_vec));
+        __m512i and3_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a3_vec, b3_vec));
+        __m512i or3_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a3_vec, b3_vec));
+        intersection = _mm512_reduce_add_epi64( //
+            _mm512_add_epi64(and3_count_vec, _mm512_add_epi64(and2_count_vec, and1_count_vec)));
+        union_ = _mm512_reduce_add_epi64( //
+            _mm512_add_epi64(or3_count_vec, _mm512_add_epi64(or2_count_vec, or1_count_vec)));
+    }
+    else if (n_words <= 256) { // Up to 2048 bits.
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words - 192);
+        __m512i a1_vec = _mm512_loadu_epi8(a);
+        __m512i b1_vec = _mm512_loadu_epi8(b);
+        __m512i a2_vec = _mm512_loadu_epi8(a + 64);
+        __m512i b2_vec = _mm512_loadu_epi8(b + 64);
+        __m512i a3_vec = _mm512_loadu_epi8(a + 128);
+        __m512i b3_vec = _mm512_loadu_epi8(b + 128);
+        __m512i a4_vec = _mm512_maskz_loadu_epi8(mask, a + 192);
+        __m512i b4_vec = _mm512_maskz_loadu_epi8(mask, b + 192);
+        __m512i and1_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a1_vec, b1_vec));
+        __m512i or1_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a1_vec, b1_vec));
+        __m512i and2_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a2_vec, b2_vec));
+        __m512i or2_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a2_vec, b2_vec));
+        __m512i and3_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a3_vec, b3_vec));
+        __m512i or3_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a3_vec, b3_vec));
+        __m512i and4_count_vec = _mm512_popcnt_epi64(_mm512_and_si512(a4_vec, b4_vec));
+        __m512i or4_count_vec = _mm512_popcnt_epi64(_mm512_or_si512(a4_vec, b4_vec));
+        intersection = _mm512_reduce_add_epi64(_mm512_add_epi64(_mm512_add_epi64(and4_count_vec, and3_count_vec),
+                                                                _mm512_add_epi64(and2_count_vec, and1_count_vec)));
+        union_ = _mm512_reduce_add_epi64(_mm512_add_epi64(_mm512_add_epi64(or4_count_vec, or3_count_vec),
+                                                          _mm512_add_epi64(or2_count_vec, or1_count_vec)));
+    }
+    else {
+        __m512i and_count_vec = _mm512_setzero_si512(), or_count_vec = _mm512_setzero_si512();
+        __m512i a_vec, b_vec;
+
+    simsimd_jaccard_b8_ice_cycle:
+        if (n_words < 64) {
+            __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
+            a_vec = _mm512_maskz_loadu_epi8(mask, a);
+            b_vec = _mm512_maskz_loadu_epi8(mask, b);
+            n_words = 0;
+        }
+        else {
+            a_vec = _mm512_loadu_epi8(a);
+            b_vec = _mm512_loadu_epi8(b);
+            a += 64, b += 64, n_words -= 64;
+        }
+        __m512i and_vec = _mm512_and_si512(a_vec, b_vec);
+        __m512i or_vec = _mm512_or_si512(a_vec, b_vec);
+        and_count_vec = _mm512_add_epi64(and_count_vec, _mm512_popcnt_epi64(and_vec));
+        or_count_vec = _mm512_add_epi64(or_count_vec, _mm512_popcnt_epi64(or_vec));
+        if (n_words) goto simsimd_jaccard_b8_ice_cycle;
+
+        intersection = _mm512_reduce_add_epi64(and_count_vec);
+        union_ = _mm512_reduce_add_epi64(or_count_vec);
     }
-    __m512i and_vec = _mm512_and_si512(a_vec, b_vec);
-    __m512i or_vec = _mm512_or_si512(a_vec, b_vec);
-    intersection_vec = _mm512_add_epi64(intersection_vec, _mm512_popcnt_epi64(and_vec));
-    union_vec = _mm512_add_epi64(union_vec, _mm512_popcnt_epi64(or_vec));
-    if (n_words)
-        goto simsimd_jaccard_b8_ice_cycle;
-
-    simsimd_size_t intersection = _mm512_reduce_add_epi64(intersection_vec),
-                   union_ = _mm512_reduce_add_epi64(union_vec);
     *result = (union_ != 0) ? 1 - (simsimd_f64_t)intersection / (simsimd_f64_t)union_ : 1;
 }
 
@@ -225,33 +436,31 @@ simsimd_jaccard_b8_ice_cycle:
 #pragma GCC target("popcnt")
 #pragma clang attribute push(__attribute__((target("popcnt"))), apply_to = function)
 
-SIMSIMD_PUBLIC void simsimd_hamming_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                               simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_hamming_b8_haswell(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                               simsimd_distance_t *result) {
     // x86 supports unaligned loads and works just fine with the scalar version for small vectors.
     simsimd_size_t differences = 0;
     for (; n_words >= 8; n_words -= 8, a += 8, b += 8)
-        differences += _mm_popcnt_u64(*(simsimd_u64_t const*)a ^ *(simsimd_u64_t const*)b);
-    for (; n_words; --n_words, ++a, ++b)
-        differences += _mm_popcnt_u32(*a ^ *b);
+        differences += _mm_popcnt_u64(*(simsimd_u64_t const *)a ^ *(simsimd_u64_t const *)b);
+    for (; n_words; --n_words, ++a, ++b) differences += _mm_popcnt_u32(*a ^ *b);
     *result = differences;
 }
 
-SIMSIMD_PUBLIC void simsimd_jaccard_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
-                                               simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_haswell(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
+                                               simsimd_distance_t *result) {
     // x86 supports unaligned loads and works just fine with the scalar version for small vectors.
     simsimd_size_t intersection = 0, union_ = 0;
     for (; n_words >= 8; n_words -= 8, a += 8, b += 8)
-        intersection += _mm_popcnt_u64(*(simsimd_u64_t const*)a & *(simsimd_u64_t const*)b),
-            union_ += _mm_popcnt_u64(*(simsimd_u64_t const*)a | *(simsimd_u64_t const*)b);
-    for (; n_words; --n_words, ++a, ++b)
-        intersection += _mm_popcnt_u32(*a & *b), union_ += _mm_popcnt_u32(*a | *b);
+        intersection += _mm_popcnt_u64(*(simsimd_u64_t const *)a & *(simsimd_u64_t const *)b),
+            union_ += _mm_popcnt_u64(*(simsimd_u64_t const *)a | *(simsimd_u64_t const *)b);
+    for (; n_words; --n_words, ++a, ++b) intersection += _mm_popcnt_u32(*a & *b), union_ += _mm_popcnt_u32(*a | *b);
     *result = (union_ != 0) ? 1 - (simsimd_f64_t)intersection / (simsimd_f64_t)union_ : 1;
 }
 
 #pragma clang attribute pop
 #pragma GCC pop_options
 #endif // SIMSIMD_TARGET_HASWELL
-#endif // SIMSIMD_TARGET_X86
+#endif // _SIMSIMD_TARGET_X86
 
 #ifdef __cplusplus
 }