faiss 0.2.5 → 0.2.7

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -135,7 +135,7 @@ int dgesvd_(
  * VectorTransform
  *********************************************/
 
-float* VectorTransform::apply(Index::idx_t n, const float* x) const {
+float* VectorTransform::apply(idx_t n, const float* x) const {
     float* xt = new float[n * d_out];
     apply_noalloc(n, x, xt);
     return xt;
@@ -166,8 +166,7 @@ LinearTransform::LinearTransform(int d_in, int d_out, bool have_bias)
     is_trained = false; // will be trained when A and b are initialized
 }
 
-void LinearTransform::apply_noalloc(Index::idx_t n, const float* x, float* xt)
-        const {
+void LinearTransform::apply_noalloc(idx_t n, const float* x, float* xt) const {
     FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
 
     float c_factor;
@@ -348,7 +347,7 @@ void RandomRotationMatrix::init(int seed) {
     is_trained = true;
 }
 
-void RandomRotationMatrix::train(Index::idx_t /*n*/, const float* /*x*/) {
+void RandomRotationMatrix::train(idx_t /*n*/, const float* /*x*/) {
     // initialize with some arbitrary seed
     init(12345);
 }
@@ -442,7 +441,7 @@ void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
 
 } // namespace
 
-void PCAMatrix::train(Index::idx_t n, const float* x) {
+void PCAMatrix::train(idx_t n, const float* x) {
     const float* x_in = x;
 
     x = fvecs_maybe_subsample(
@@ -733,7 +732,7 @@ ITQMatrix::ITQMatrix(int d)
         : LinearTransform(d, d, false), max_iter(50), seed(123) {}
 
 /** translated from fbcode/deeplearning/catalyzer/catalyzer/quantizers.py */
-void ITQMatrix::train(Index::idx_t n, const float* xf) {
+void ITQMatrix::train(idx_t n, const float* xf) {
     size_t d = d_in;
     std::vector<double> rotation(d * d);
 
@@ -957,8 +956,7 @@ void ITQTransform::train(idx_t n, const float* x) {
     is_trained = true;
 }
 
-void ITQTransform::apply_noalloc(Index::idx_t n, const float* x, float* xt)
-        const {
+void ITQTransform::apply_noalloc(idx_t n, const float* x, float* xt) const {
     FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
 
     std::unique_ptr<float[]> x_norm(new float[n * d_in]);
@@ -1003,7 +1001,7 @@ OPQMatrix::OPQMatrix(int d, int M, int d2)
     pq = nullptr;
 }
 
-void OPQMatrix::train(Index::idx_t n, const float* x) {
+void OPQMatrix::train(idx_t n, const float* x) {
     const float* x_in = x;
 
     x = fvecs_maybe_subsample(d_in, (size_t*)&n, max_train_points, x, verbose);
@@ -1261,7 +1259,7 @@ CenteringTransform::CenteringTransform(int d) : VectorTransform(d, d) {
     is_trained = false;
 }
 
-void CenteringTransform::train(Index::idx_t n, const float* x) {
+void CenteringTransform::train(idx_t n, const float* x) {
     FAISS_THROW_IF_NOT_MSG(n > 0, "need at least one training vector");
     mean.resize(d_in, 0);
     for (idx_t i = 0; i < n; i++) {

data/vendor/faiss/faiss/VectorTransform.h

@@ -23,8 +23,6 @@ namespace faiss {
 
 /** Any transformation applied on a set of vectors */
 struct VectorTransform {
-    typedef Index::idx_t idx_t;
-
     int d_in;  ///! input dimension
     int d_out; ///! output dimension
 
@@ -122,7 +120,7 @@ struct RandomRotationMatrix : LinearTransform {
     /// must be called before the transform is used
     void init(int seed);
 
-    // intializes with an arbitrary seed
+    // initializes with an arbitrary seed
     void train(idx_t n, const float* x) override;
 
     RandomRotationMatrix() {}

data/vendor/faiss/faiss/clone_index.cpp

@@ -16,18 +16,24 @@
 
 #include <faiss/Index2Layer.h>
 #include <faiss/IndexAdditiveQuantizer.h>
+#include <faiss/IndexAdditiveQuantizerFastScan.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIVF.h>
+#include <faiss/IndexIVFAdditiveQuantizerFastScan.h>
 #include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFPQ.h>
+#include <faiss/IndexIVFPQFastScan.h>
 #include <faiss/IndexIVFPQR.h>
 #include <faiss/IndexIVFSpectralHash.h>
 #include <faiss/IndexLSH.h>
 #include <faiss/IndexLattice.h>
 #include <faiss/IndexNSG.h>
 #include <faiss/IndexPQ.h>
+#include <faiss/IndexPQFastScan.h>
 #include <faiss/IndexPreTransform.h>
+#include <faiss/IndexRefine.h>
+#include <faiss/IndexRowwiseMinMax.h>
 #include <faiss/IndexScalarQuantizer.h>
 #include <faiss/MetaIndexes.h>
 #include <faiss/VectorTransform.h>
@@ -36,6 +42,9 @@
 #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>
 
 namespace faiss {
 
@@ -71,39 +80,220 @@ VectorTransform* Cloner::clone_VectorTransform(const VectorTransform* vt) {
 IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
     TRYCLONE(IndexIVFPQR, ivf)
     TRYCLONE(IndexIVFPQ, ivf)
+
+    TRYCLONE(IndexIVFLocalSearchQuantizer, ivf)
+    TRYCLONE(IndexIVFProductLocalSearchQuantizer, ivf)
+    TRYCLONE(IndexIVFProductResidualQuantizer, ivf)
+    TRYCLONE(IndexIVFResidualQuantizer, ivf)
+
+    TRYCLONE(IndexIVFLocalSearchQuantizerFastScan, ivf)
+    TRYCLONE(IndexIVFProductLocalSearchQuantizerFastScan, ivf)
+    TRYCLONE(IndexIVFProductResidualQuantizerFastScan, ivf)
+    TRYCLONE(IndexIVFResidualQuantizerFastScan, ivf)
+    TRYCLONE(IndexIVFPQFastScan, ivf)
+
+    TRYCLONE(IndexIVFFlatDedup, ivf)
     TRYCLONE(IndexIVFFlat, ivf)
+
+    TRYCLONE(IndexIVFSpectralHash, ivf)
+
     TRYCLONE(IndexIVFScalarQuantizer, ivf) {
         FAISS_THROW_MSG("clone not supported for this type of IndexIVF");
     }
     return nullptr;
 }
 
+IndexRefine* clone_IndexRefine(const IndexRefine* ir) {
+    TRYCLONE(IndexRefineFlat, ir)
+    TRYCLONE(IndexRefine, ir) {
+        FAISS_THROW_MSG("clone not supported for this type of IndexRefine");
+    }
+}
+
+IndexIDMap* clone_IndexIDMap(const IndexIDMap* im) {
+    TRYCLONE(IndexIDMap2, im)
+    TRYCLONE(IndexIDMap, im) {
+        FAISS_THROW_MSG("clone not supported for this type of IndexIDMap");
+    }
+}
+
+IndexHNSW* clone_IndexHNSW(const IndexHNSW* ihnsw) {
+    TRYCLONE(IndexHNSW2Level, ihnsw)
+    TRYCLONE(IndexHNSWFlat, ihnsw)
+    TRYCLONE(IndexHNSWPQ, ihnsw)
+    TRYCLONE(IndexHNSWSQ, ihnsw)
+    TRYCLONE(IndexHNSW, ihnsw) {
+        FAISS_THROW_MSG("clone not supported for this type of IndexHNSW");
+    }
+}
+
+IndexNNDescent* clone_IndexNNDescent(const IndexNNDescent* innd) {
+    TRYCLONE(IndexNNDescentFlat, innd)
+    TRYCLONE(IndexNNDescent, innd) {
+        FAISS_THROW_MSG("clone not supported for this type of IndexNNDescent");
+    }
+}
+
+IndexNSG* clone_IndexNSG(const IndexNSG* insg) {
+    TRYCLONE(IndexNSGFlat, insg)
+    TRYCLONE(IndexNSGPQ, insg)
+    TRYCLONE(IndexNSGSQ, insg)
+    TRYCLONE(IndexNSG, insg) {
+        FAISS_THROW_MSG("clone not supported for this type of IndexNNDescent");
+    }
+}
+
+IndexRowwiseMinMaxBase* clone_IndexRowwiseMinMax(
+        const IndexRowwiseMinMaxBase* irmmb) {
+    TRYCLONE(IndexRowwiseMinMaxFP16, irmmb)
+    TRYCLONE(IndexRowwiseMinMax, irmmb) {
+        FAISS_THROW_MSG(
+                "clone not supported for this type of IndexRowwiseMinMax");
+    }
+}
+
+#define TRYCAST(classname) classname* res = dynamic_cast<classname*>(index)
+
+void reset_AdditiveQuantizerIndex(Index* index) {
+    auto clone_ProductQuantizers =
+            [](std::vector<AdditiveQuantizer*>& quantizers) {
+                for (auto& q : quantizers) {
+                    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;
+    } else {
+        FAISS_THROW_MSG(
+                "clone not supported for this type of additive quantizer index");
+    }
+}
+
+Index* clone_AdditiveQuantizerIndex(const Index* index) {
+    // IndexAdditiveQuantizer
+    TRYCLONE(IndexResidualQuantizer, index)
+    TRYCLONE(IndexProductResidualQuantizer, index)
+    TRYCLONE(IndexLocalSearchQuantizer, index)
+    TRYCLONE(IndexProductLocalSearchQuantizer, index)
+
+    // IndexFastScan
+    TRYCLONE(IndexResidualQuantizerFastScan, index)
+    TRYCLONE(IndexLocalSearchQuantizerFastScan, index)
+    TRYCLONE(IndexProductResidualQuantizerFastScan, index)
+    TRYCLONE(IndexProductLocalSearchQuantizerFastScan, index)
+
+    // AdditiveCoarseQuantizer
+    TRYCLONE(ResidualCoarseQuantizer, index)
+    TRYCLONE(LocalSearchCoarseQuantizer, index) {
+        FAISS_THROW_MSG(
+                "clone not supported for this type of additive quantizer index");
+    }
+}
+
+namespace {
+
+IndexHNSW* clone_HNSW(const IndexHNSW* ihnsw) {
+    TRYCLONE(IndexHNSWFlat, ihnsw)
+    TRYCLONE(IndexHNSWPQ, ihnsw)
+    TRYCLONE(IndexHNSWSQ, ihnsw)
+    return new IndexHNSW(*ihnsw);
+}
+
+InvertedLists* clone_InvertedLists(const InvertedLists* invlists) {
+    if (auto* ails = dynamic_cast<const ArrayInvertedLists*>(invlists)) {
+        return new ArrayInvertedLists(*ails);
+    }
+    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);
+        }
+        return bils2;
+    }
+    FAISS_THROW_FMT(
+            "clone not supported for this type of inverted lists %s",
+            typeid(*invlists).name());
+}
+
+} // anonymous namespace
+
 Index* Cloner::clone_Index(const Index* index) {
     TRYCLONE(IndexPQ, index)
     TRYCLONE(IndexLSH, index)
+
+    // IndexFlat
+    TRYCLONE(IndexFlat1D, index)
     TRYCLONE(IndexFlatL2, index)
     TRYCLONE(IndexFlatIP, index)
     TRYCLONE(IndexFlat, index)
+
     TRYCLONE(IndexLattice, index)
-    TRYCLONE(IndexResidualQuantizer, index)
+    TRYCLONE(IndexRandom, index)
+    TRYCLONE(IndexPQFastScan, index)
+
     TRYCLONE(IndexScalarQuantizer, index)
     TRYCLONE(MultiIndexQuantizer, index)
-    TRYCLONE(ResidualCoarseQuantizer, index)
+
     if (const IndexIVF* ivf = dynamic_cast<const IndexIVF*>(index)) {
         IndexIVF* res = clone_IndexIVF(ivf);
         if (ivf->invlists == nullptr) {
             res->invlists = nullptr;
-        } else if (
-                auto* ails = dynamic_cast<const ArrayInvertedLists*>(
-                        ivf->invlists)) {
-            res->invlists = new ArrayInvertedLists(*ails);
-            res->own_invlists = true;
         } else {
-            FAISS_THROW_MSG(
-                    "clone not supported for this type of inverted lists");
+            res->invlists = clone_InvertedLists(ivf->invlists);
+            res->own_invlists = true;
         }
+
         res->own_fields = true;
         res->quantizer = clone_Index(ivf->quantizer);
+
+        if (dynamic_cast<const IndexIVFAdditiveQuantizerFastScan*>(res) ||
+            dynamic_cast<const IndexIVFAdditiveQuantizer*>(res)) {
+            reset_AdditiveQuantizerIndex(res);
+        }
         return res;
     } else if (
             const IndexPreTransform* ipt =
@@ -122,19 +312,18 @@ Index* Cloner::clone_Index(const Index* index) {
         return res;
     } else if (
             const IndexIDMap* idmap = dynamic_cast<const IndexIDMap*>(index)) {
-        const IndexIDMap2* idmap2 = dynamic_cast<const IndexIDMap2*>(index);
-        IndexIDMap* res =
-                idmap2 ? new IndexIDMap2(*idmap2) : new IndexIDMap(*idmap);
+        IndexIDMap* res = clone_IndexIDMap(idmap);
         res->own_fields = true;
         res->index = clone_Index(idmap->index);
         return res;
     } else if (const IndexHNSW* ihnsw = dynamic_cast<const IndexHNSW*>(index)) {
-        IndexHNSW* res = new IndexHNSW(*ihnsw);
+        IndexHNSW* res = clone_IndexHNSW(ihnsw);
         res->own_fields = true;
-        res->storage = clone_Index(ihnsw->storage);
+        // make sure we don't get a GPU index here
+        res->storage = Cloner::clone_Index(ihnsw->storage);
         return res;
     } else if (const IndexNSG* insg = dynamic_cast<const IndexNSG*>(index)) {
-        IndexNSG* res = new IndexNSG(*insg);
+        IndexNSG* res = clone_IndexNSG(insg);
 
         // copy the dynamic allocated graph
         auto& new_graph = res->nsg.final_graph;
@@ -147,7 +336,7 @@ Index* Cloner::clone_Index(const Index* index) {
     } else if (
             const IndexNNDescent* innd =
                     dynamic_cast<const IndexNNDescent*>(index)) {
-        IndexNNDescent* res = new IndexNNDescent(*innd);
+        IndexNNDescent* res = clone_IndexNNDescent(innd);
         res->own_fields = true;
         res->storage = clone_Index(innd->storage);
         return res;
@@ -157,11 +346,36 @@ Index* Cloner::clone_Index(const Index* index) {
         res->q1.own_fields = true;
         res->q1.quantizer = clone_Index(i2l->q1.quantizer);
         return res;
+    } else if (
+            const IndexRefine* ir = dynamic_cast<const IndexRefine*>(index)) {
+        IndexRefine* res = clone_IndexRefine(ir);
+        res->own_fields = true;
+        res->base_index = clone_Index(ir->base_index);
+        if (ir->refine_index != nullptr) {
+            res->own_refine_index = true;
+            res->refine_index = clone_Index(ir->refine_index);
+        }
+        return res;
+    } else if (
+            const IndexRowwiseMinMaxBase* irmmb =
+                    dynamic_cast<const IndexRowwiseMinMaxBase*>(index)) {
+        IndexRowwiseMinMaxBase* res = clone_IndexRowwiseMinMax(irmmb);
+        res->own_fields = true;
+        res->index = clone_Index(irmmb->index);
+    } else if (
+            dynamic_cast<const IndexAdditiveQuantizerFastScan*>(index) ||
+            dynamic_cast<const IndexAdditiveQuantizer*>(index) ||
+            dynamic_cast<const AdditiveCoarseQuantizer*>(index)) {
+        Index* res = clone_AdditiveQuantizerIndex(index);
+        reset_AdditiveQuantizerIndex(res);
+        return res;
     } else {
-        FAISS_THROW_MSG("clone not supported for this type of Index");
+        FAISS_THROW_FMT(
+                "clone not supported for this Index type %s",
+                typeid(*index).name());
     }
     return nullptr;
-}
+} // namespace
 
 Quantizer* clone_Quantizer(const Quantizer* quant) {
     TRYCLONE(ResidualQuantizer, quant)

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

@@ -1,4 +1,9 @@
-// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+/**
+ * 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
 
@@ -11,19 +16,32 @@
 //   * PQ[1]x8
 // Additionally, AVX2 and ARM versions support
 //   * Residual[1]x8,PQ[2]x10
+//   * Residual[1]x8,PQ[2]x12
 //   * Residual[1]x8,PQ[2]x16
 //   * Residual[1]x10,PQ[2]x10
+//   * Residual[1]x10,PQ[2]x12
 //   * Residual[1]x10,PQ[2]x16
+//   * Residual[1]x12,PQ[2]x10
+//   * Residual[1]x12,PQ[2]x12
+//   * Residual[1]x12,PQ[2]x16
 //   * Residual[1]x16,PQ[2]x10
+//   * Residual[1]x16,PQ[2]x12
 //   * Residual[1]x16,PQ[2]x16
 //   * Residual1x[9-16 bit],PQ[1]x10 (such as Residual1x9,PQ16x10)
 //   * * (use with COARSE_BITS=16)
+//   * Residual1x[9-16 bit],PQ[1]x12 (such as Residual1x9,PQ16x12)
+//   * * (use with COARSE_BITS=16)
 //   * Residual1x[9-16 bit],PQ[1]x16 (such as Residual1x9,PQ16x16)
 //   * * (use with COARSE_BITS=16)
 //   * PQ[1]x10
+//   * PQ[1]x12
 //   * PQ[1]x16
-// Unfortunately, currently Faiss does not support something like
-//   IVF256,PQ16x10np
+//   * IVF256,PQ[1]x10 (such as IVF256,PQ16x10np)
+//   * IVF256,PQ[1]x12 (such as IVF256,PQ16x12np)
+//   * IVF256,PQ[1]x16 (such as IVF256,PQ16x16np)
+//   * IVF[2^9-2^16 bit],PQ[1]x10 (such as IVF1024,PQ16x10np)
+//   * IVF[2^9-2^16 bit],PQ[1]x12 (such as IVF1024,PQ16x12np)
+//   * IVF[2^9-2^16 bit],PQ[1]x16 (such as IVF1024,PQ16x16np)
 //
 // The goal was to achieve the maximum performance, so the template version it
 // is. The provided index families share the same code for sa_decode.
@@ -57,6 +75,10 @@
 //   decoder.
 // For example, "Residual4x10,PQ16x10np" for 256-dim data translates into
 //   Index2LevelDecoder<256,64,16,10,10>
+// For example, "IVF1024,PQ16x10np" for 256-dim data translates into
+//   Index2LevelDecoder<256,256,16,10,10>. But as there are only 1 coarse code
+//   element, Index2LevelDecoder<256,256,16,16,10> can be used as a faster
+//   decoder.
 //
 // Additional supported values for COARSE_BITS and FINE_BITS may be added later.
 //

data/vendor/faiss/faiss/cppcontrib/detail/CoarseBitType.h

@@ -1,3 +1,10 @@
+/**
+ * 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
 
 #include <cstdint>

data/vendor/faiss/faiss/cppcontrib/detail/UintReader.h

@@ -1,3 +1,10 @@
+/**
+ * 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
 
 #include <cstdint>
@@ -120,6 +127,72 @@ struct Uint10Reader {
     }
 };
 
+// reduces the number of read operations from RAM
+///////////////////////////////////////////////
+// 76543210 76543210 76543210 76543210 76543210 76543210
+// 00000000 0000
+//              1111 11111111
+//                            22222222 2222
+//                                         3333 33333333
+template <intptr_t N_ELEMENTS, intptr_t CPOS>
+struct Uint12Reader {
+    static_assert(CPOS < N_ELEMENTS, "CPOS should be less than N_ELEMENTS");
+
+    static intptr_t get(const uint8_t* const __restrict codes) {
+        // Read using 4-bytes or 2-bytes.
+
+        constexpr intptr_t ELEMENT_TO_READ = CPOS / 4;
+        constexpr intptr_t SUB_ELEMENT = CPOS % 4;
+
+        switch (SUB_ELEMENT) {
+            case 0: {
+                if (N_ELEMENTS > CPOS + 2) {
+                    const uint32_t code32 = *reinterpret_cast<const uint32_t*>(
+                            codes + ELEMENT_TO_READ * 6);
+                    return (code32 & 0b0000111111111111);
+                } else {
+                    const uint16_t code16 = *reinterpret_cast<const uint16_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 0);
+                    return (code16 & 0b0000111111111111);
+                }
+            }
+            case 1: {
+                if (N_ELEMENTS > CPOS + 1) {
+                    const uint32_t code32 = *reinterpret_cast<const uint32_t*>(
+                            codes + ELEMENT_TO_READ * 6);
+                    return (code32 & 0b111111111111000000000000) >> 12;
+                } else {
+                    const uint16_t code16 = *reinterpret_cast<const uint16_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 1);
+                    return (code16 & 0b1111111111110000) >> 4;
+                }
+            }
+            case 2: {
+                if (N_ELEMENTS > CPOS + 1) {
+                    const uint32_t code32 = *reinterpret_cast<const uint32_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 2);
+                    return (code32 & 0b000011111111111100000000) >> 8;
+                } else {
+                    const uint16_t code16 = *reinterpret_cast<const uint16_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 3);
+                    return (code16 & 0b0000111111111111);
+                }
+            }
+            case 3: {
+                if (N_ELEMENTS > CPOS) {
+                    const uint32_t code32 = *reinterpret_cast<const uint32_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 2);
+                    return (code32 & 0b11111111111100000000000000000000) >> 20;
+                } else {
+                    const uint16_t code16 = *reinterpret_cast<const uint16_t*>(
+                            codes + ELEMENT_TO_READ * 6 + 4);
+                    return (code16 & 0b1111111111110000) >> 4;
+                }
+            }
+        }
+    }
+};
+
 // reduces the number of read operations from RAM
 template <intptr_t N_ELEMENTS, intptr_t CPOS>
 struct Uint16Reader {
@@ -173,6 +246,11 @@ struct UintReaderImplType<N_ELEMENTS, 10, CPOS> {
     using reader_type = Uint10Reader<N_ELEMENTS, CPOS>;
 };
 
+template <intptr_t N_ELEMENTS, intptr_t CPOS>
+struct UintReaderImplType<N_ELEMENTS, 12, CPOS> {
+    using reader_type = Uint12Reader<N_ELEMENTS, CPOS>;
+};
+
 template <intptr_t N_ELEMENTS, intptr_t CPOS>
 struct UintReaderImplType<N_ELEMENTS, 16, CPOS> {
     using reader_type = Uint16Reader<N_ELEMENTS, CPOS>;

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

@@ -1,4 +1,10 @@
-// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+/**
+ * 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.
+ */
+
 #ifndef LEVEL2_AVX2_INL_H
 #define LEVEL2_AVX2_INL_H
 
@@ -1851,8 +1857,14 @@ struct Index2LevelDecoderImpl<
 } // namespace
 
 // Suitable for IVF256,PQ[1]x8
+// Subtable for IVF256,PQ[1]x10 (such as IVF256,PQ16x10np)
+// Subtable for IVF256,PQ[1]x12 (such as IVF256,PQ16x12np)
+// Suitable for IVF256,PQ[1]x16 (such as IVF256,PQ16x16np)
 // Suitable for Residual[1]x8,PQ[2]x8
-// Suitable for IVF[9-16 bit],PQ[1]x8 (such as IVF1024,PQ16np)
+// Suitable for IVF[2^9-2^16 bit],PQ[1]x8 (such as IVF1024,PQ16np)
+// Suitable for IVF[2^9-2^16 bit],PQ[1]x10 (such as IVF1024,PQ16x10np)
+// Suitable for IVF[2^9-2^16 bit],PQ[1]x12 (such as IVF1024,PQ16x12np)
+// Suitable for IVF[2^9-2^16 bit],PQ[1]x16 (such as IVF1024,PQ16x16np)
 // Suitable for Residual[1]x[9-16 bit],PQ[2]x[3] (such as Residual2x9,PQ8)
 template <
         intptr_t DIM,
@@ -1862,11 +1874,13 @@ template <
         intptr_t FINE_BITS = 8>
 struct Index2LevelDecoder {
     static_assert(
-            COARSE_BITS == 8 || COARSE_BITS == 10 || COARSE_BITS == 16,
-            "Only 8, 10 or 16 bits are currently supported for COARSE_BITS");
+            COARSE_BITS == 8 || COARSE_BITS == 10 || COARSE_BITS == 12 ||
+                    COARSE_BITS == 16,
+            "Only 8, 10, 12 or 16 bits are currently supported for COARSE_BITS");
     static_assert(
-            FINE_BITS == 8 || FINE_BITS == 10 || FINE_BITS == 16,
-            "Only 8, 10 or 16 bits are currently supported for FINE_BITS");
+            FINE_BITS == 8 || FINE_BITS == 10 || FINE_BITS == 12 ||
+                    FINE_BITS == 16,
+            "Only 8, 10, 12 or 16 bits are currently supported for FINE_BITS");
 
     static constexpr intptr_t dim = DIM;
     static constexpr intptr_t coarseSize = COARSE_SIZE;

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

@@ -1,4 +1,10 @@
-// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+/**
+ * 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.
+ */
+
 #ifndef LEVEL2_INL_H
 #define LEVEL2_INL_H