faiss 0.6.0 → 0.6.2

data/vendor/faiss/faiss/VectorTransform.h

@@ -26,8 +26,8 @@ struct VectorTransform {
     int d_in;  ///! input dimension
     int d_out; ///! output dimension
 
-    explicit VectorTransform(int d_in = 0, int d_out = 0)
-            : d_in(d_in), d_out(d_out), is_trained(true) {}
+    explicit VectorTransform(int d_in_val = 0, int d_out_val = 0)
+            : d_in(d_in_val), d_out(d_out_val), is_trained(true) {}
 
     /// set if the VectorTransform does not require training, or if
     /// training is done already
@@ -82,9 +82,9 @@ struct LinearTransform : VectorTransform {
 
     /// both d_in > d_out and d_out < d_in are supported
     explicit LinearTransform(
-            int d_in = 0,
-            int d_out = 0,
-            bool have_bias = false);
+            int din = 0,
+            int dout = 0,
+            bool have_bias_in = false);
 
     /// same as apply, but result is pre-allocated
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;
@@ -114,8 +114,8 @@ struct LinearTransform : VectorTransform {
 /// Randomly rotate a set of vectors
 struct RandomRotationMatrix : LinearTransform {
     /// both d_in > d_out and d_out < d_in are supported
-    RandomRotationMatrix(int d_in, int d_out)
-            : LinearTransform(d_in, d_out, false) {}
+    RandomRotationMatrix(int d_in_val, int d_out_val)
+            : LinearTransform(d_in_val, d_out_val, false) {}
 
     /// must be called before the transform is used
     void init(int seed);
@@ -183,10 +183,10 @@ struct PCAMatrix : LinearTransform {
 
     // the final matrix is computed after random rotation and/or whitening
     explicit PCAMatrix(
-            int d_in = 0,
-            int d_out = 0,
-            float eigen_power = 0,
-            bool random_rotation = false);
+            int din = 0,
+            int dout = 0,
+            float eigen_power_in = 0,
+            bool random_rotation_in = false);
 
     /// train on n vectors. If n < d_in then the eigenvector matrix
     /// will be completed with 0s
@@ -233,7 +233,7 @@ struct ITQTransform : VectorTransform {
     // concatenation of PCA + ITQ transformation
     LinearTransform pca_then_itq;
 
-    explicit ITQTransform(int d_in = 0, int d_out = 0, bool do_pca = false);
+    explicit ITQTransform(int din = 0, int dout = 0, bool do_pca_in = false);
 
     void train(idx_t n, const float* x) override;
 
@@ -267,7 +267,7 @@ struct OPQMatrix : LinearTransform {
     ProductQuantizer* pq = nullptr;
 
     /// if d2 != -1, output vectors of this dimension
-    explicit OPQMatrix(int d = 0, int M = 1, int d2 = -1);
+    explicit OPQMatrix(int d = 0, int M_in = 1, int d2 = -1);
 
     void train(idx_t n, const float* x) override;
 };
@@ -280,12 +280,12 @@ struct RemapDimensionsTransform : VectorTransform {
     /// -1 -> set output to 0
     std::vector<int> map;
 
-    RemapDimensionsTransform(int d_in, int d_out, const int* map);
+    RemapDimensionsTransform(int din, int dout, const int* map);
 
     /// remap input to output, skipping or inserting dimensions as needed
     /// if uniform: distribute dimensions uniformly
     /// otherwise just take the d_out first ones.
-    RemapDimensionsTransform(int d_in, int d_out, bool uniform = true);
+    RemapDimensionsTransform(int din, int dout, bool uniform = true);
 
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;
 
@@ -301,7 +301,7 @@ struct RemapDimensionsTransform : VectorTransform {
 struct NormalizationTransform : VectorTransform {
     float norm;
 
-    explicit NormalizationTransform(int d, float norm = 2.0);
+    explicit NormalizationTransform(int d, float norm_in = 2.0);
     NormalizationTransform();
 
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;

data/vendor/faiss/faiss/build.cpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "faiss/build.h"
+
+namespace faiss {
+
+bool has_omp() {
+    int omp_available = 1;
+    // Detect whether OpenMP is enabled by using the 'max' reduction to render
+    // the below assignment a no-op. This works:
+    //  1) without starting any threads
+    //  2) irrespective of the current thread limit
+#pragma omp parallel reduction(max : omp_available) num_threads(1)
+    omp_available = 0;
+    return omp_available != 0;
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/build.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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
+
+namespace faiss {
+
+// Returns true iff `faiss` was compiled with non-mocked OpenMP support.
+bool has_omp();
+
+} // namespace faiss

data/vendor/faiss/faiss/clone_index.cpp

@@ -102,8 +102,8 @@ IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
     TRYCLONE(IndexIVFRaBitQ, ivf)
 
     TRYCLONE(IndexIVFFlatDedup, ivf)
-    TRYCLONE(IndexIVFFlat, ivf)
     TRYCLONE(IndexIVFFlatPanorama, ivf)
+    TRYCLONE(IndexIVFFlat, ivf)
 
     TRYCLONE(IndexIVFSpectralHash, ivf)
 
@@ -173,7 +173,7 @@ IndexRowwiseMinMaxBase* clone_IndexRowwiseMinMax(
     }
 }
 
-#define TRYCAST(classname) classname* res = dynamic_cast<classname*>(index)
+#define TRYCAST(classname, var) auto* var = dynamic_cast<classname*>(index)
 
 void reset_AdditiveQuantizerIndex(Index* index) {
     auto clone_ProductQuantizers =
@@ -182,50 +182,50 @@ void reset_AdditiveQuantizerIndex(Index* index) {
                     q = dynamic_cast<AdditiveQuantizer*>(clone_Quantizer(q));
                 }
             };
-    if (TRYCAST(IndexIVFLocalSearchQuantizerFastScan)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexIVFResidualQuantizerFastScan)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizerFastScan)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexIVFProductResidualQuantizerFastScan)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexIVFLocalSearchQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexIVFResidualQuantizer)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizer)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexIVFProductResidualQuantizer)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexLocalSearchQuantizerFastScan)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexResidualQuantizerFastScan)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexProductLocalSearchQuantizerFastScan)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexProductResidualQuantizerFastScan)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexLocalSearchQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexResidualQuantizer)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexProductLocalSearchQuantizer)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexProductResidualQuantizer)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(LocalSearchCoarseQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(ResidualCoarseQuantizer)) {
-        res->aq = &res->rq;
+    if (TRYCAST(IndexIVFLocalSearchQuantizerFastScan, r1)) {
+        r1->aq = &r1->lsq;
+    } else if (TRYCAST(IndexIVFResidualQuantizerFastScan, r2)) {
+        r2->aq = &r2->rq;
+    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizerFastScan, r3)) {
+        r3->aq = &r3->plsq;
+        clone_ProductQuantizers(r3->plsq.quantizers);
+    } else if (TRYCAST(IndexIVFProductResidualQuantizerFastScan, r4)) {
+        r4->aq = &r4->prq;
+        clone_ProductQuantizers(r4->prq.quantizers);
+    } else if (TRYCAST(IndexIVFLocalSearchQuantizer, r5)) {
+        r5->aq = &r5->lsq;
+    } else if (TRYCAST(IndexIVFResidualQuantizer, r6)) {
+        r6->aq = &r6->rq;
+    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizer, r7)) {
+        r7->aq = &r7->plsq;
+        clone_ProductQuantizers(r7->plsq.quantizers);
+    } else if (TRYCAST(IndexIVFProductResidualQuantizer, r8)) {
+        r8->aq = &r8->prq;
+        clone_ProductQuantizers(r8->prq.quantizers);
+    } else if (TRYCAST(IndexLocalSearchQuantizerFastScan, r9)) {
+        r9->aq = &r9->lsq;
+    } else if (TRYCAST(IndexResidualQuantizerFastScan, r10)) {
+        r10->aq = &r10->rq;
+    } else if (TRYCAST(IndexProductLocalSearchQuantizerFastScan, r11)) {
+        r11->aq = &r11->plsq;
+        clone_ProductQuantizers(r11->plsq.quantizers);
+    } else if (TRYCAST(IndexProductResidualQuantizerFastScan, r12)) {
+        r12->aq = &r12->prq;
+        clone_ProductQuantizers(r12->prq.quantizers);
+    } else if (TRYCAST(IndexLocalSearchQuantizer, r13)) {
+        r13->aq = &r13->lsq;
+    } else if (TRYCAST(IndexResidualQuantizer, r14)) {
+        r14->aq = &r14->rq;
+    } else if (TRYCAST(IndexProductLocalSearchQuantizer, r15)) {
+        r15->aq = &r15->plsq;
+        clone_ProductQuantizers(r15->plsq.quantizers);
+    } else if (TRYCAST(IndexProductResidualQuantizer, r16)) {
+        r16->aq = &r16->prq;
+        clone_ProductQuantizers(r16->prq.quantizers);
+    } else if (TRYCAST(LocalSearchCoarseQuantizer, r17)) {
+        r17->aq = &r17->lsq;
+    } else if (TRYCAST(ResidualCoarseQuantizer, r18)) {
+        r18->aq = &r18->rq;
     } else {
         FAISS_THROW_MSG(
                 "clone not supported for this type of additive quantizer index");
@@ -319,7 +319,7 @@ Index* Cloner::clone_Index(const Index* index) {
         res->metric_arg = ipt->metric_arg;
 
         res->index = clone_Index(ipt->index);
-        for (int i = 0; i < ipt->chain.size(); i++) {
+        for (size_t i = 0; i < ipt->chain.size(); i++) {
             res->chain.push_back(clone_VectorTransform(ipt->chain[i]));
         }
         res->own_fields = true;
@@ -377,6 +377,7 @@ Index* Cloner::clone_Index(const Index* index) {
         IndexRowwiseMinMaxBase* res = clone_IndexRowwiseMinMax(irmmb);
         res->own_fields = true;
         res->index = clone_Index(irmmb->index);
+        return res;
     } else if (
             dynamic_cast<const IndexAdditiveQuantizerFastScan*>(index) ||
             dynamic_cast<const IndexAdditiveQuantizer*>(index) ||

data/vendor/faiss/faiss/cppcontrib/SaDecodeKernels.h

@@ -313,7 +313,7 @@
 #ifdef __AVX2__
 #include <faiss/cppcontrib/sa_decode/Level2-avx2-inl.h>
 #include <faiss/cppcontrib/sa_decode/PQ-avx2-inl.h>
-#elif defined(__ARM_NEON)
+#elif defined(__ARM_NEON) || defined(__aarch64__)
 #include <faiss/cppcontrib/sa_decode/Level2-neon-inl.h>
 #include <faiss/cppcontrib/sa_decode/PQ-neon-inl.h>
 #else

data/vendor/faiss/faiss/cppcontrib/sa_decode/Level2-avx2-inl.h

@@ -1785,72 +1785,72 @@ struct Index2LevelDecoderImpl<
 
     // process 1 sample
     static void store(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            float* const __restrict outputStore) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            float* const __restrict /*outputStore*/) {}
 
     // process 1 sample
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Each code uses its own coarse pq centroids table and fine pq centroids table.
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqCoarseCentroids1,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqCoarseCentroids1*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Coarse pq centroids table and fine pq centroids table are shared among codes.
     static void accum(
-            const float* const __restrict pqCoarseCentroids,
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids*/,
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Each code uses its own coarse pq centroids table and fine pq centroids table.
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqCoarseCentroids1,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const float* const __restrict pqCoarseCentroids2,
-            const float* const __restrict pqFineCentroids2,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqCoarseCentroids1*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const float* const __restrict /*pqCoarseCentroids2*/,
+            const float* const __restrict /*pqFineCentroids2*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Coarse pq centroids table and fine pq centroids table are shared among codes.
     static void accum(
-            const float* const __restrict pqCoarseCentroids,
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids*/,
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // clang-format on
 };

data/vendor/faiss/faiss/cppcontrib/sa_decode/Level2-inl.h

@@ -8,6 +8,12 @@
 #ifndef LEVEL2_INL_H
 #define LEVEL2_INL_H
 
+// GCC does not recognize #pragma unroll (Clang extension)
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#endif
+
 #include <cstddef>
 #include <cstdint>
 
@@ -464,4 +470,9 @@ struct Index2LevelDecoder {
 
 } // namespace cppcontrib
 } // namespace faiss
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
 #endif // LEVEL2_INL_H