faiss 0.6.0 → 0.6.2

data/vendor/faiss/faiss/utils/distances_simd.cpp

@@ -9,19 +9,20 @@
 
 #include <faiss/utils/distances.h>
 
-#include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/platform_macros.h>
-#include <faiss/utils/simdlib.h>
+#include <faiss/impl/simdlib/simdlib_dispatch.h>
 
-#define AUTOVEC_LEVEL SIMDLevel::NONE
+#define THE_SIMD_LEVEL SIMDLevel::NONE
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/simd_impl/distances_autovec-inl.h>
 
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/distances_simdlib256.h>
+
 namespace faiss {
 
 /*******
@@ -168,177 +169,3 @@ int fvec_madd_and_argmin<SIMDLevel::NONE>(
 }
 
 } // namespace faiss
-
-namespace faiss {
-
-/***************************************************************************
- * PQ tables computations
- ***************************************************************************/
-
-namespace {
-
-/// compute the IP for dsub = 2 for 8 centroids and 4 sub-vectors at a time
-template <bool is_inner_product>
-void pq2_8cents_table(
-        const simd8float32 centroids[8],
-        const simd8float32 x,
-        float* out,
-        size_t ldo,
-        size_t nout = 4) {
-    simd8float32 ips[4];
-
-    for (int i = 0; i < 4; i++) {
-        simd8float32 p1, p2;
-        if (is_inner_product) {
-            p1 = x * centroids[2 * i];
-            p2 = x * centroids[2 * i + 1];
-        } else {
-            p1 = (x - centroids[2 * i]);
-            p1 = p1 * p1;
-            p2 = (x - centroids[2 * i + 1]);
-            p2 = p2 * p2;
-        }
-        ips[i] = hadd(p1, p2);
-    }
-
-    simd8float32 ip02a = geteven(ips[0], ips[1]);
-    simd8float32 ip02b = geteven(ips[2], ips[3]);
-    simd8float32 ip0 = getlow128(ip02a, ip02b);
-    simd8float32 ip2 = gethigh128(ip02a, ip02b);
-
-    simd8float32 ip13a = getodd(ips[0], ips[1]);
-    simd8float32 ip13b = getodd(ips[2], ips[3]);
-    simd8float32 ip1 = getlow128(ip13a, ip13b);
-    simd8float32 ip3 = gethigh128(ip13a, ip13b);
-
-    switch (nout) {
-        case 4:
-            ip3.storeu(out + 3 * ldo);
-            [[fallthrough]];
-        case 3:
-            ip2.storeu(out + 2 * ldo);
-            [[fallthrough]];
-        case 2:
-            ip1.storeu(out + 1 * ldo);
-            [[fallthrough]];
-        case 1:
-            ip0.storeu(out);
-    }
-}
-
-simd8float32 load_simd8float32_partial(const float* x, int n) {
-    ALIGNED(32) float tmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-    float* wp = tmp;
-    for (int i = 0; i < n; i++) {
-        *wp++ = *x++;
-    }
-    return simd8float32(tmp);
-}
-
-} // anonymous namespace
-
-void compute_PQ_dis_tables_dsub2(
-        size_t d,
-        size_t ksub,
-        const float* all_centroids,
-        size_t nx,
-        const float* x,
-        bool is_inner_product,
-        float* dis_tables) {
-    size_t M = d / 2;
-    FAISS_THROW_IF_NOT(ksub % 8 == 0);
-
-    for (size_t m0 = 0; m0 < M; m0 += 4) {
-        int m1 = std::min(M, m0 + 4);
-        for (int k0 = 0; k0 < ksub; k0 += 8) {
-            simd8float32 centroids[8];
-            for (int k = 0; k < 8; k++) {
-                ALIGNED(32) float centroid[8];
-                size_t wp = 0;
-                size_t rp = (m0 * ksub + k + k0) * 2;
-                for (int m = m0; m < m1; m++) {
-                    centroid[wp++] = all_centroids[rp];
-                    centroid[wp++] = all_centroids[rp + 1];
-                    rp += 2 * ksub;
-                }
-                centroids[k] = simd8float32(centroid);
-            }
-            for (size_t i = 0; i < nx; i++) {
-                simd8float32 xi;
-                if (m1 == m0 + 4) {
-                    xi.loadu(x + i * d + m0 * 2);
-                } else {
-                    xi = load_simd8float32_partial(
-                            x + i * d + m0 * 2, 2 * (m1 - m0));
-                }
-
-                if (is_inner_product) {
-                    pq2_8cents_table<true>(
-                            centroids,
-                            xi,
-                            dis_tables + (i * M + m0) * ksub + k0,
-                            ksub,
-                            m1 - m0);
-                } else {
-                    pq2_8cents_table<false>(
-                            centroids,
-                            xi,
-                            dis_tables + (i * M + m0) * ksub + k0,
-                            ksub,
-                            m1 - m0);
-                }
-            }
-        }
-    }
-}
-
-/*********************************************************
- * Vector to vector functions
- *********************************************************/
-
-void fvec_sub(size_t d, const float* a, const float* b, float* c) {
-    size_t i;
-    for (i = 0; i + 7 < d; i += 8) {
-        simd8float32 ci, ai, bi;
-        ai.loadu(a + i);
-        bi.loadu(b + i);
-        ci = ai - bi;
-        ci.storeu(c + i);
-    }
-    // finish non-multiple of 8 remainder
-    for (; i < d; i++) {
-        c[i] = a[i] - b[i];
-    }
-}
-
-void fvec_add(size_t d, const float* a, const float* b, float* c) {
-    size_t i;
-    for (i = 0; i + 7 < d; i += 8) {
-        simd8float32 ci, ai, bi;
-        ai.loadu(a + i);
-        bi.loadu(b + i);
-        ci = ai + bi;
-        ci.storeu(c + i);
-    }
-    // finish non-multiple of 8 remainder
-    for (; i < d; i++) {
-        c[i] = a[i] + b[i];
-    }
-}
-
-void fvec_add(size_t d, const float* a, float b, float* c) {
-    size_t i;
-    simd8float32 bv(b);
-    for (i = 0; i + 7 < d; i += 8) {
-        simd8float32 ci, ai;
-        ai.loadu(a + i);
-        ci = ai + bv;
-        ci.storeu(c + i);
-    }
-    // finish non-multiple of 8 remainder
-    for (; i < d; i++) {
-        c[i] = a[i] + b;
-    }
-}
-
-} // namespace faiss

data/vendor/faiss/faiss/utils/extra_distances.cpp

@@ -7,6 +7,7 @@
 
 // -*- c++ -*-
 
+#include <faiss/utils/distances_dispatch.h>
 #include <faiss/utils/extra_distances.h>
 
 #include <omp.h>
@@ -41,14 +42,14 @@ struct ExtraDistanceComputer : FlatCodesDistanceComputer {
     }
 
     ExtraDistanceComputer(
-            const VD& vd,
+            const VD& vd_in,
             const float* xb,
-            size_t nb,
-            const float* q = nullptr)
-            : FlatCodesDistanceComputer((uint8_t*)xb, vd.d * sizeof(float)),
-              vd(vd),
-              nb(nb),
-              q(q),
+            size_t nb_in,
+            const float* q_in = nullptr)
+            : FlatCodesDistanceComputer((uint8_t*)xb, vd_in.d * sizeof(float)),
+              vd(vd_in),
+              nb(nb_in),
+              q(q_in),
               b(xb) {}
 
     void set_query(const float* x) override {
@@ -119,7 +120,7 @@ void knn_extra_metrics(
             size_t i1 = std::min(i0 + check_period, nx);
 
 #pragma omp parallel for
-            for (int64_t i = i0; i < i1; i++) {
+            for (int64_t i = i0; i < static_cast<int64_t>(i1); i++) {
                 const float* x_i = x + i * d;
                 const float* y_j = y;
                 size_t j;

data/vendor/faiss/faiss/utils/extra_distances.h

@@ -10,12 +10,13 @@
 /** In this file are the implementations of extra metrics beyond L2
  *  and inner product */
 
-#include <stdint.h>
+#include <cstdint>
 
-#include <faiss/Index.h>
+#include <faiss/MetricType.h>
+#include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
-
-#include <faiss/utils/Heap.h>
+#include <faiss/utils/ordered_key_value.h>
+#include <faiss/utils/simd_levels.h>
 
 namespace faiss {
 
@@ -100,6 +101,31 @@ inline auto with_metric_type(MetricType metric, LambdaType&& action) {
 }
 #endif // SWIG
 
-} // namespace faiss
+#ifndef SWIG
+
+/***************************************************************************
+ * VectorDistance base class - contains common data members and type defs
+ * VectorDistance struct template - specializations for each metric type
+ **************************************************************************/
+
+template <MetricType mt, SIMDLevel level>
+struct VectorDistance {
+    size_t d;
+    float metric_arg;
+
+    VectorDistance(size_t d, float metric_arg) : d(d), metric_arg(metric_arg) {}
 
-#include <faiss/utils/extra_distances-inl.h>
+    static constexpr MetricType metric = mt;
+    static constexpr bool is_similarity = is_similarity_metric(mt);
+
+    using C = typename std::conditional<
+            is_similarity_metric(mt),
+            CMin<float, int64_t>,
+            CMax<float, int64_t>>::type;
+
+    float operator()(const float* x, const float* y) const;
+};
+
+#endif // SWIG
+
+} // namespace faiss

data/vendor/faiss/faiss/utils/hamming-inl.h

@@ -10,9 +10,9 @@
 namespace faiss {
 
 // BitstringWriter and BitstringReader functions
-inline BitstringWriter::BitstringWriter(uint8_t* code, size_t code_size)
-        : code(code), code_size(code_size), i(0) {
-    memset(code, 0, code_size);
+inline BitstringWriter::BitstringWriter(uint8_t* code_in, size_t code_size_in)
+        : code(code_in), code_size(code_size_in), i(0) {
+    memset(code_in, 0, code_size_in);
 }
 
 inline void BitstringWriter::write(uint64_t x, int nbit) {
@@ -36,8 +36,10 @@ inline void BitstringWriter::write(uint64_t x, int nbit) {
     }
 }
 
-inline BitstringReader::BitstringReader(const uint8_t* code, size_t code_size)
-        : code(code), code_size(code_size), i(0) {}
+inline BitstringReader::BitstringReader(
+        const uint8_t* code_in,
+        size_t code_size_in)
+        : code(code_in), code_size(code_size_in), i(0) {}
 
 inline uint64_t BitstringReader::read(int nbit) {
     assert(code_size * 8 >= nbit + i);
@@ -85,18 +87,18 @@ struct HCounterState {
     int k;
 
     HCounterState(
-            int* counters,
-            int64_t* ids_per_dis,
+            int* counters_in,
+            int64_t* ids_per_dis_in,
             const uint8_t* x,
             int d,
-            int k)
-            : counters(counters),
-              ids_per_dis(ids_per_dis),
+            int k_in)
+            : counters(counters_in),
+              ids_per_dis(ids_per_dis_in),
               hc(x, d / 8),
               thres(d + 1),
               count_lt(0),
               count_eq(0),
-              k(k) {}
+              k(k_in) {}
 
     void update_counter(const uint8_t* y, size_t j) {
         int32_t dis = hc.hamming(y);