faiss 0.5.3 → 0.6.1

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);
@@ -126,6 +126,29 @@ struct RandomRotationMatrix : LinearTransform {
     RandomRotationMatrix() {}
 };
 
+/** Three rounds of random sign-flip + Fast Walsh-Hadamard Transform.
+ * Produces a pseudo-random rotation in O(d log d) time.
+ * d_out is the smallest power of 2 >= d_in (zero-padded as needed).
+ */
+struct HadamardRotation : VectorTransform {
+    uint32_t seed{};
+
+    /// Sign-flip vectors, each of size d_out, generated from seed.
+    std::vector<float> signs1, signs2, signs3;
+
+    explicit HadamardRotation(int d, uint32_t seed = 12345);
+
+    void init(uint32_t seed_in);
+
+    void train(idx_t n, const float* x) override;
+
+    void apply_noalloc(idx_t n, const float* x, float* xt) const override;
+
+    void check_identical(const VectorTransform& other) const override;
+
+    HadamardRotation() {}
+};
+
 /** Applies a principal component analysis on a set of vectors,
  *  with optionally whitening and random rotation. */
 struct PCAMatrix : LinearTransform {
@@ -160,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
@@ -210,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;
 
@@ -244,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;
 };
@@ -257,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;
 
@@ -278,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

@@ -27,6 +27,8 @@
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQFastScan.h>
 #include <faiss/IndexIVFPQR.h>
+#include <faiss/IndexIVFRaBitQ.h>
+#include <faiss/IndexIVFRaBitQFastScan.h>
 #include <faiss/IndexIVFSpectralHash.h>
 #include <faiss/IndexLSH.h>
 #include <faiss/IndexLattice.h>
@@ -41,11 +43,11 @@
 #include <faiss/MetaIndexes.h>
 #include <faiss/VectorTransform.h>
 
+#include <faiss/impl/CodePacker.h>
 #include <faiss/impl/LocalSearchQuantizer.h>
 #include <faiss/impl/ProductQuantizer.h>
 #include <faiss/impl/ResidualQuantizer.h>
 #include <faiss/impl/ScalarQuantizer.h>
-#include <faiss/impl/pq4_fast_scan.h>
 
 #include <faiss/invlists/BlockInvertedLists.h>
 
@@ -96,9 +98,12 @@ IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
     TRYCLONE(IndexIVFResidualQuantizerFastScan, ivf)
     TRYCLONE(IndexIVFPQFastScan, ivf)
 
+    TRYCLONE(IndexIVFRaBitQFastScan, ivf)
+    TRYCLONE(IndexIVFRaBitQ, ivf)
+
     TRYCLONE(IndexIVFFlatDedup, ivf)
-    TRYCLONE(IndexIVFFlat, ivf)
     TRYCLONE(IndexIVFFlatPanorama, ivf)
+    TRYCLONE(IndexIVFFlat, ivf)
 
     TRYCLONE(IndexIVFSpectralHash, ivf)
 
@@ -168,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 =
@@ -177,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");
@@ -257,9 +262,7 @@ InvertedLists* clone_InvertedLists(const InvertedLists* invlists) {
     if (auto* bils = dynamic_cast<const BlockInvertedLists*>(invlists)) {
         auto* bils2 = new BlockInvertedLists(*bils);
         if (bils->packer) {
-            auto* packerPQ4 = dynamic_cast<const CodePackerPQ4*>(bils->packer);
-            FAISS_THROW_IF_NOT(packerPQ4);
-            bils2->packer = new CodePackerPQ4(*packerPQ4);
+            bils2->packer = bils->packer->clone();
         }
         return bils2;
     }
@@ -316,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;
@@ -374,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/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

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

@@ -1428,63 +1428,63 @@ struct IndexPQDecoderImpl<
 
     // process 1 sample
     static void store(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            float* const __restrict outputStore) {}
+            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 pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            float* const __restrict outputAccum) {}
+            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 fine pq centroids table.
     static void accum(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Fine pq centroids table is shared among codes.
     static void accum(
-            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 /*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 fine pq centroids table.
     static void accum(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const float* const __restrict pqFineCentroids2,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const float* const __restrict /*pqFineCentroids2*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Fine pq centroids table is shared among codes.
     static void accum(
-            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 /*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/PQ-inl.h

@@ -8,6 +8,12 @@
 #ifndef PQ_INL_H
 #define PQ_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>
 
@@ -254,4 +260,9 @@ struct IndexPQDecoder {
 
 } // namespace cppcontrib
 } // namespace faiss
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
 #endif // PQ_INL_H

data/vendor/faiss/faiss/{cppcontrib/factory_tools.cpp → factory_tools.cpp}

@@ -7,7 +7,7 @@
 
 // -*- c++ -*-
 
-#include <faiss/cppcontrib/factory_tools.h>
+#include <faiss/factory_tools.h>
 
 #include <map>
 
@@ -38,6 +38,11 @@ const std::map<faiss::ScalarQuantizer::QuantizerType, std::string> sq_types = {
         {faiss::ScalarQuantizer::QT_bf16, "SQbf16"},
         {faiss::ScalarQuantizer::QT_8bit_direct_signed, "SQ8_direct_signed"},
         {faiss::ScalarQuantizer::QT_8bit_direct, "SQ8_direct"},
+        {faiss::ScalarQuantizer::QT_1bit_tqmse, "SQtqmse1"},
+        {faiss::ScalarQuantizer::QT_2bit_tqmse, "SQtqmse2"},
+        {faiss::ScalarQuantizer::QT_3bit_tqmse, "SQtqmse3"},
+        {faiss::ScalarQuantizer::QT_4bit_tqmse, "SQtqmse4"},
+        {faiss::ScalarQuantizer::QT_8bit_tqmse, "SQtqmse8"},
 };
 
 int get_hnsw_M(const faiss::IndexHNSW* index) {

data/vendor/faiss/faiss/gpu/GpuCloner.cpp

@@ -64,7 +64,7 @@ void ToCPUCloner::merge_index(Index* dst, Index* src, bool successive_ids) {
         FAISS_ASSERT(ifl2);
         ifl->merge_from(*ifl2, successive_ids ? ifl->ntotal : 0);
     } else {
-        FAISS_ASSERT(!"merging not implemented for this type of class");
+        FAISS_ASSERT(false && "merging not implemented for this type of class");
     }
 }