faiss 0.3.0 → 0.3.1

data/vendor/faiss/faiss/utils/hamming_distance/generic-inl.h

@@ -275,24 +275,31 @@ struct HammingComputerDefault {
                     len -= 8;
                     accu += popcount64(a64[i] ^ b64[i]);
                     i++;
+                    [[fallthrough]];
                     case 7:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 6:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 5:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 4:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 3:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 2:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 1:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
@@ -302,20 +309,28 @@ struct HammingComputerDefault {
             const uint8_t* a = a8 + 8 * quotient8;
             const uint8_t* b = b8 + 8 * quotient8;
             switch (remainder8) {
+                [[fallthrough]];
                 case 7:
                     accu += hamdis_tab_ham_bytes[a[6] ^ b[6]];
+                    [[fallthrough]];
                 case 6:
                     accu += hamdis_tab_ham_bytes[a[5] ^ b[5]];
+                    [[fallthrough]];
                 case 5:
                     accu += hamdis_tab_ham_bytes[a[4] ^ b[4]];
+                    [[fallthrough]];
                 case 4:
                     accu += hamdis_tab_ham_bytes[a[3] ^ b[3]];
+                    [[fallthrough]];
                 case 3:
                     accu += hamdis_tab_ham_bytes[a[2] ^ b[2]];
+                    [[fallthrough]];
                 case 2:
                     accu += hamdis_tab_ham_bytes[a[1] ^ b[1]];
+                    [[fallthrough]];
                 case 1:
                     accu += hamdis_tab_ham_bytes[a[0] ^ b[0]];
+                    [[fallthrough]];
                 default:
                     break;
             }
@@ -329,93 +344,6 @@ struct HammingComputerDefault {
     }
 };
 
-// more inefficient than HammingComputerDefault (obsolete)
-struct HammingComputerM8 {
-    const uint64_t* a;
-    int n;
-
-    HammingComputerM8() {}
-
-    HammingComputerM8(const uint8_t* a8, int code_size) {
-        set(a8, code_size);
-    }
-
-    void set(const uint8_t* a8, int code_size) {
-        assert(code_size % 8 == 0);
-        a = (uint64_t*)a8;
-        n = code_size / 8;
-    }
-
-    int hamming(const uint8_t* b8) const {
-        const uint64_t* b = (uint64_t*)b8;
-        int accu = 0;
-        for (int i = 0; i < n; i++)
-            accu += popcount64(a[i] ^ b[i]);
-        return accu;
-    }
-
-    inline int get_code_size() const {
-        return n * 8;
-    }
-};
-
-// more inefficient than HammingComputerDefault (obsolete)
-struct HammingComputerM4 {
-    const uint32_t* a;
-    int n;
-
-    HammingComputerM4() {}
-
-    HammingComputerM4(const uint8_t* a4, int code_size) {
-        set(a4, code_size);
-    }
-
-    void set(const uint8_t* a4, int code_size) {
-        assert(code_size % 4 == 0);
-        a = (uint32_t*)a4;
-        n = code_size / 4;
-    }
-
-    int hamming(const uint8_t* b8) const {
-        const uint32_t* b = (uint32_t*)b8;
-        int accu = 0;
-        for (int i = 0; i < n; i++)
-            accu += popcount64(a[i] ^ b[i]);
-        return accu;
-    }
-
-    inline int get_code_size() const {
-        return n * 4;
-    }
-};
-
-/***************************************************************************
- * Equivalence with a template class when code size is known at compile time
- **************************************************************************/
-
-// default template
-template <int CODE_SIZE>
-struct HammingComputer : HammingComputerDefault {
-    HammingComputer(const uint8_t* a, int code_size)
-            : HammingComputerDefault(a, code_size) {}
-};
-
-#define SPECIALIZED_HC(CODE_SIZE)                                    \
-    template <>                                                      \
-    struct HammingComputer<CODE_SIZE> : HammingComputer##CODE_SIZE { \
-        HammingComputer(const uint8_t* a)                            \
-                : HammingComputer##CODE_SIZE(a, CODE_SIZE) {}        \
-    }
-
-SPECIALIZED_HC(4);
-SPECIALIZED_HC(8);
-SPECIALIZED_HC(16);
-SPECIALIZED_HC(20);
-SPECIALIZED_HC(32);
-SPECIALIZED_HC(64);
-
-#undef SPECIALIZED_HC
-
 /***************************************************************************
  * generalized Hamming = number of bytes that are different between
  * two codes.

data/vendor/faiss/faiss/utils/hamming_distance/hamdis-inl.h

@@ -23,4 +23,61 @@
 #include <faiss/utils/hamming_distance/generic-inl.h>
 #endif
 
+namespace faiss {
+
+/***************************************************************************
+ * Equivalence with a template class when code size is known at compile time
+ **************************************************************************/
+
+// default template
+template <int CODE_SIZE>
+struct HammingComputer : HammingComputerDefault {
+    HammingComputer(const uint8_t* a, int code_size)
+            : HammingComputerDefault(a, code_size) {}
+};
+
+#define SPECIALIZED_HC(CODE_SIZE)                                    \
+    template <>                                                      \
+    struct HammingComputer<CODE_SIZE> : HammingComputer##CODE_SIZE { \
+        HammingComputer(const uint8_t* a)                            \
+                : HammingComputer##CODE_SIZE(a, CODE_SIZE) {}        \
+    }
+
+SPECIALIZED_HC(4);
+SPECIALIZED_HC(8);
+SPECIALIZED_HC(16);
+SPECIALIZED_HC(20);
+SPECIALIZED_HC(32);
+SPECIALIZED_HC(64);
+
+#undef SPECIALIZED_HC
+
+/***************************************************************************
+ * Dispatching function that takes a code size and a consumer object
+ * the consumer object should contain a retun type t and a operation template
+ * function f() that to be called to perform the operation.
+ **************************************************************************/
+
+template <class Consumer, class... Types>
+typename Consumer::T dispatch_HammingComputer(
+        int code_size,
+        Consumer& consumer,
+        Types... args) {
+    switch (code_size) {
+#define DISPATCH_HC(CODE_SIZE) \
+    case CODE_SIZE:            \
+        return consumer.template f<HammingComputer##CODE_SIZE>(args...);
+        DISPATCH_HC(4);
+        DISPATCH_HC(8);
+        DISPATCH_HC(16);
+        DISPATCH_HC(20);
+        DISPATCH_HC(32);
+        DISPATCH_HC(64);
+        default:
+            return consumer.template f<HammingComputerDefault>(args...);
+    }
+}
+
+} // namespace faiss
+
 #endif

data/vendor/faiss/faiss/utils/hamming_distance/neon-inl.h

@@ -260,7 +260,6 @@ struct HammingComputer32 {
     }
 
     inline int hamming(const uint8_t* b8) const {
-        const uint64_t* b = (uint64_t*)b8;
         uint8x16_t b0 = vld1q_u8(b8);
         uint8x16_t b1 = vld1q_u8(b8 + 16);
 
@@ -338,24 +337,31 @@ struct HammingComputerDefault {
                     len -= 8;
                     accu += popcount64(a64[i] ^ b64[i]);
                     i++;
+                    [[fallthrough]];
                     case 7:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 6:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 5:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 4:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 3:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 2:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
+                        [[fallthrough]];
                     case 1:
                         accu += popcount64(a64[i] ^ b64[i]);
                         i++;
@@ -367,18 +373,25 @@ struct HammingComputerDefault {
             switch (remainder8) {
                 case 7:
                     accu += hamdis_tab_ham_bytes[a[6] ^ b[6]];
+                    [[fallthrough]];
                 case 6:
                     accu += hamdis_tab_ham_bytes[a[5] ^ b[5]];
+                    [[fallthrough]];
                 case 5:
                     accu += hamdis_tab_ham_bytes[a[4] ^ b[4]];
+                    [[fallthrough]];
                 case 4:
                     accu += hamdis_tab_ham_bytes[a[3] ^ b[3]];
+                    [[fallthrough]];
                 case 3:
                     accu += hamdis_tab_ham_bytes[a[2] ^ b[2]];
+                    [[fallthrough]];
                 case 2:
                     accu += hamdis_tab_ham_bytes[a[1] ^ b[1]];
+                    [[fallthrough]];
                 case 1:
                     accu += hamdis_tab_ham_bytes[a[0] ^ b[0]];
+                    [[fallthrough]];
                 default:
                     break;
             }
@@ -392,109 +405,6 @@ struct HammingComputerDefault {
     }
 };
 
-// more inefficient than HammingComputerDefault (obsolete)
-struct HammingComputerM8 {
-    const uint64_t* a;
-    int n;
-
-    HammingComputerM8() {}
-
-    HammingComputerM8(const uint8_t* a8, int code_size) {
-        set(a8, code_size);
-    }
-
-    void set(const uint8_t* a8, int code_size) {
-        assert(code_size % 8 == 0);
-        a = (uint64_t*)a8;
-        n = code_size / 8;
-    }
-
-    int hamming(const uint8_t* b8) const {
-        const uint64_t* b = (uint64_t*)b8;
-        int n4 = (n / 4) * 4;
-        int accu = 0;
-
-        int i = 0;
-        for (; i < n4; i += 4) {
-            accu += ::faiss::hamming<256>(a + i, b + i);
-        }
-        for (; i < n; i++) {
-            accu += popcount64(a[i] ^ b[i]);
-        }
-        return accu;
-    }
-
-    inline int get_code_size() const {
-        return n * 8;
-    }
-};
-
-// more inefficient than HammingComputerDefault (obsolete)
-struct HammingComputerM4 {
-    const uint32_t* a;
-    int n;
-
-    HammingComputerM4() {}
-
-    HammingComputerM4(const uint8_t* a4, int code_size) {
-        set(a4, code_size);
-    }
-
-    void set(const uint8_t* a4, int code_size) {
-        assert(code_size % 4 == 0);
-        a = (uint32_t*)a4;
-        n = code_size / 4;
-    }
-
-    int hamming(const uint8_t* b8) const {
-        const uint32_t* b = (uint32_t*)b8;
-
-        int n8 = (n / 8) * 8;
-        int accu = 0;
-
-        int i = 0;
-        for (; i < n8; i += 8) {
-            accu += ::faiss::hamming<256>(
-                    (const uint64_t*)(a + i), (const uint64_t*)(b + i));
-        }
-        for (; i < n; i++) {
-            accu += popcount64(a[i] ^ b[i]);
-        }
-        return accu;
-    }
-
-    inline int get_code_size() const {
-        return n * 4;
-    }
-};
-
-/***************************************************************************
- * Equivalence with a template class when code size is known at compile time
- **************************************************************************/
-
-// default template
-template <int CODE_SIZE>
-struct HammingComputer : HammingComputerDefault {
-    HammingComputer(const uint8_t* a, int code_size)
-            : HammingComputerDefault(a, code_size) {}
-};
-
-#define SPECIALIZED_HC(CODE_SIZE)                                    \
-    template <>                                                      \
-    struct HammingComputer<CODE_SIZE> : HammingComputer##CODE_SIZE { \
-        HammingComputer(const uint8_t* a)                            \
-                : HammingComputer##CODE_SIZE(a, CODE_SIZE) {}        \
-    }
-
-SPECIALIZED_HC(4);
-SPECIALIZED_HC(8);
-SPECIALIZED_HC(16);
-SPECIALIZED_HC(20);
-SPECIALIZED_HC(32);
-SPECIALIZED_HC(64);
-
-#undef SPECIALIZED_HC
-
 /***************************************************************************
  * generalized Hamming = number of bytes that are different between
  * two codes.

data/vendor/faiss/faiss/utils/partitioning.cpp

@@ -206,7 +206,8 @@ typename C::T partition_fuzzy_median3(
         assert(n_eq_1 <= n_eq);
     }
 
-    int wp = compress_array<C>(vals, ids, n, thresh, n_eq_1);
+    [[maybe_unused]] const int wp =
+            compress_array<C>(vals, ids, n, thresh, n_eq_1);
 
     assert(wp == q);
     if (q_out) {
@@ -750,8 +751,6 @@ typename C::T partition_fuzzy(
         size_t q_min,
         size_t q_max,
         size_t* q_out) {
-    // the code below compiles and runs without AVX2 but it's slower than
-    // the scalar implementation
 #ifdef __AVX2__
     constexpr bool is_uint16 = std::is_same<typename C::T, uint16_t>::value;
     if (is_uint16 && is_aligned_pointer(vals)) {
@@ -882,7 +881,7 @@ static const simd32uint8 shifts = simd32uint8::create<
 // 2-bit accumulator: we can add only up to 3 elements
 // on output we return 2*4-bit results
 // preproc returns either an index in 0..7 or 0xffff
-// that yeilds a 0 when used in the table look-up
+// that yields a 0 when used in the table look-up
 template <int N, class Preproc>
 void compute_accu2(
         const uint16_t*& data,

data/vendor/faiss/faiss/utils/prefetch.h

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+// prefetches
+
+#ifdef __AVX__
+
+// AVX
+
+#include <xmmintrin.h>
+
+inline void prefetch_L1(const void* address) {
+    _mm_prefetch((const char*)address, _MM_HINT_T0);
+}
+inline void prefetch_L2(const void* address) {
+    _mm_prefetch((const char*)address, _MM_HINT_T1);
+}
+inline void prefetch_L3(const void* address) {
+    _mm_prefetch((const char*)address, _MM_HINT_T2);
+}
+
+#elif defined(__aarch64__)
+
+// ARM64
+
+#ifdef _MSC_VER
+
+// todo: arm on MSVC
+inline void prefetch_L1(const void* address) {}
+inline void prefetch_L2(const void* address) {}
+inline void prefetch_L3(const void* address) {}
+
+#else
+// arm on non-MSVC
+
+inline void prefetch_L1(const void* address) {
+    __builtin_prefetch(address, 0, 3);
+}
+inline void prefetch_L2(const void* address) {
+    __builtin_prefetch(address, 0, 2);
+}
+inline void prefetch_L3(const void* address) {
+    __builtin_prefetch(address, 0, 1);
+}
+#endif
+
+#else
+
+// a generic platform
+
+#ifdef _MSC_VER
+
+inline void prefetch_L1(const void* address) {}
+inline void prefetch_L2(const void* address) {}
+inline void prefetch_L3(const void* address) {}
+
+#else
+
+inline void prefetch_L1(const void* address) {
+    __builtin_prefetch(address, 0, 3);
+}
+inline void prefetch_L2(const void* address) {
+    __builtin_prefetch(address, 0, 2);
+}
+inline void prefetch_L3(const void* address) {
+    __builtin_prefetch(address, 0, 1);
+}
+
+#endif
+
+#endif

data/vendor/faiss/faiss/utils/quantize_lut.cpp

@@ -24,20 +24,6 @@ namespace quantize_lut {
 
 namespace {
 
-float round_uint8_and_mul(float* tab, size_t n) {
-    float max = 0;
-    for (int i = 0; i < n; i++) {
-        if (fabs(tab[i]) > max) {
-            max = fabs(tab[i]);
-        }
-    }
-    float multiplier = 127 / max;
-    for (int i = 0; i < n; i++) {
-        tab[i] = floorf(tab[i] * multiplier + 128);
-    }
-    return multiplier;
-}
-
 // there can be NaNs in tables, they should be ignored
 float tab_min(const float* tab, size_t n) {
     float min = HUGE_VAL;

data/vendor/faiss/faiss/utils/simdlib_avx2.h

@@ -202,12 +202,6 @@ struct simd16uint16 : simd256bit {
         return simd16uint16(_mm256_cmpeq_epi16(lhs.i, rhs.i));
     }
 
-    bool is_same(simd16uint16 other) const {
-        const __m256i pcmp = _mm256_cmpeq_epi16(i, other.i);
-        unsigned bitmask = _mm256_movemask_epi8(pcmp);
-        return (bitmask == 0xffffffffU);
-    }
-
     simd16uint16 operator~() const {
         return simd16uint16(_mm256_xor_si256(i, _mm256_set1_epi32(-1)));
     }