faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/impl/svs_io.cpp

@@ -50,7 +50,8 @@ int WriterStreambuf::overflow(int ch) {
     return wrote == 1 ? ch : traits_type::eof();
 }
 
-ReaderStreambuf::ReaderStreambuf(IOReader* rr) : r(rr), single_char_buffer(0) {
+ReaderStreambuf::ReaderStreambuf(IOReader* rr, size_t limit)
+        : r(rr), single_char_buffer(0), per_read_byte_limit(limit) {
     // Initialize with empty get area
     setg(nullptr, nullptr, nullptr);
 }
@@ -77,9 +78,17 @@ std::streamsize ReaderStreambuf::xsgetn(char* s, std::streamsize n) {
     if (n <= 0) {
         return 0;
     }
+    size_t nbytes = n;
 
-    size_t got = (*r)(s, 1, n);
-    return static_cast<std::streamsize>(got);
+    // Per-read byte limit: reject individual reads that exceed the limit,
+    // matching READVECTOR semantics where each vector allocation is
+    // independently checked against deserialization_vector_byte_limit.
+    if (per_read_byte_limit > 0 && nbytes >= per_read_byte_limit) {
+        return 0;
+    }
+
+    size_t got = (*r)(s, 1, nbytes);
+    return got;
 }
 
 } // namespace svs_io

data/vendor/faiss/faiss/impl/svs_io.h

@@ -53,9 +53,15 @@ struct WriterStreambuf : std::streambuf {
 // without intermediate buffering.
 struct ReaderStreambuf : std::streambuf {
     IOReader* r;
-    char single_char_buffer; // Single-byte buffer for underflow() operations
+    char single_char_buffer;    // Single-byte buffer for underflow() operations
+    size_t per_read_byte_limit; // Max bytes per individual read (0 = unlimited)
 
-    explicit ReaderStreambuf(IOReader* rr);
+    /// Construct with an optional per-read byte limit matching READVECTOR
+    /// semantics. Each individual xsgetn call that meets or exceeds the
+    /// limit returns 0, matching how READVECTOR rejects individual vectors
+    /// whose allocation would exceed deserialization_vector_byte_limit.
+    /// A limit of 0 means unlimited.
+    explicit ReaderStreambuf(IOReader* rr, size_t limit = 0);
     ~ReaderStreambuf() override;
 
    protected:

data/vendor/faiss/faiss/index_factory.cpp

@@ -45,7 +45,6 @@
 #include <faiss/IndexRefine.h>
 #include <faiss/IndexRowwiseMinMax.h>
 #include <faiss/IndexScalarQuantizer.h>
-#include <faiss/MetaIndexes.h>
 #include <faiss/VectorTransform.h>
 
 #include <faiss/IndexBinaryFlat.h>
@@ -55,6 +54,9 @@
 
 #ifdef FAISS_ENABLE_SVS
 #include <faiss/svs/IndexSVSFlat.h>
+#include <faiss/svs/IndexSVSIVF.h>
+#include <faiss/svs/IndexSVSIVFLVQ.h>
+#include <faiss/svs/IndexSVSIVFLeanVec.h>
 #include <faiss/svs/IndexSVSVamana.h>
 #include <faiss/svs/IndexSVSVamanaLVQ.h>
 #include <faiss/svs/IndexSVSVamanaLeanVec.h>
@@ -91,10 +93,10 @@ void find_matching_parentheses(
         int begin = 0) {
     int st = 0;
     i0 = i1 = 0;
-    for (int i = begin; i < s.length(); i++) {
+    for (size_t i = begin; i < s.length(); i++) {
         if (s[i] == '(') {
             if (st == 0) {
-                i0 = i;
+                i0 = static_cast<int>(i);
             }
             st++;
         }
@@ -102,7 +104,7 @@ void find_matching_parentheses(
         if (s[i] == ')') {
             st--;
             if (st == 0) {
-                i1 = i;
+                i1 = static_cast<int>(i);
                 return;
             }
             if (st < 0) {
@@ -128,6 +130,11 @@ char get_trains_alone(const Index* coarse_quantizer) {
     if (dynamic_cast<const IndexHNSWFlat*>(coarse_quantizer)) {
         return 2;
     }
+#ifdef FAISS_ENABLE_SVS
+    if (dynamic_cast<const IndexSVSVamana*>(coarse_quantizer)) {
+        return 2;
+    }
+#endif
     return 2; // for complicated indexes, we assume they can't be used as a
               // kmeans index
 }
@@ -155,9 +162,15 @@ std::map<std::string, ScalarQuantizer::QuantizerType> sq_types = {
         {"SQbf16", ScalarQuantizer::QT_bf16},
         {"SQ8_direct_signed", ScalarQuantizer::QT_8bit_direct_signed},
         {"SQ8_direct", ScalarQuantizer::QT_8bit_direct},
+        {"SQ0", ScalarQuantizer::QT_0bit},
+        {"SQtqmse1", ScalarQuantizer::QT_1bit_tqmse},
+        {"SQtqmse2", ScalarQuantizer::QT_2bit_tqmse},
+        {"SQtqmse3", ScalarQuantizer::QT_3bit_tqmse},
+        {"SQtqmse4", ScalarQuantizer::QT_4bit_tqmse},
+        {"SQtqmse8", ScalarQuantizer::QT_8bit_tqmse},
 };
 const std::string sq_pattern =
-        "(SQ4|SQ8|SQ6|SQfp16|SQbf16|SQ8_direct_signed|SQ8_direct)";
+        "(SQ0|SQ4|SQ8|SQ6|SQfp16|SQbf16|SQ8_direct_signed|SQ8_direct|SQtqmse1|SQtqmse2|SQtqmse3|SQtqmse4|SQtqmse8)";
 
 std::map<std::string, AdditiveQuantizer::Search_type_t> aq_search_type = {
         {"_Nfloat", AdditiveQuantizer::ST_norm_float},
@@ -183,7 +196,7 @@ AdditiveQuantizer::Search_type_t aq_parse_search_type(
         return metric == METRIC_L2 ? AdditiveQuantizer::ST_decompress
                                    : AdditiveQuantizer::ST_LUT_nonorm;
     }
-    int pos = stok.rfind('_');
+    size_t pos = stok.rfind('_');
     return aq_search_type[stok.substr(pos)];
 }
 
@@ -206,7 +219,7 @@ std::vector<size_t> aq_parse_nbits(std::string stok) {
 
 VectorTransform* parse_VectorTransform(const std::string& description, int d) {
     std::smatch sm;
-    auto match = [&sm, description](std::string pattern) {
+    auto match = [&sm, description](const std::string& pattern) {
         return re_match(description, pattern, sm);
     };
     if (match("PCA(W?)(R?)([0-9]+)")) {
@@ -264,7 +277,7 @@ Index* parse_coarse_quantizer(
         size_t& nlist,
         bool& use_2layer) {
     std::smatch sm;
-    auto match = [&sm, description](std::string pattern) {
+    auto match = [&sm, description](const std::string& pattern) {
         return re_match(description, pattern, sm);
     };
     use_2layer = false;
@@ -291,10 +304,34 @@ Index* parse_coarse_quantizer(
         int R = std::stoi(sm[2]);
         return new IndexNSGFlat(d, R, mt);
     }
+#ifdef FAISS_ENABLE_SVS
+    if (match("IVF([0-9]+[kM]?)_SVSVamana([0-9]*)(_.+)?")) {
+        nlist = parse_nlist(sm[1].str());
+        int degree = sm[2].length() > 0 ? std::stoi(sm[2]) : 32;
+        SVSStorageKind storage = SVSStorageKind::SVS_FP32;
+        if (sm[3].matched) {
+            std::string s = sm[3].str().substr(1);
+            if (s == "SQI8") {
+                storage = SVSStorageKind::SVS_SQI8;
+            } else if (s == "FP16") {
+                storage = SVSStorageKind::SVS_FP16;
+            } else if (s == "FP32") {
+                storage = SVSStorageKind::SVS_FP32;
+            } else {
+                FAISS_THROW_FMT(
+                        "unsupported SVSVamana coarse quantizer storage: %s",
+                        s.c_str());
+            }
+        }
+        return new IndexSVSVamana(d, degree, mt, storage);
+    }
+#endif
     if (match("IVF([0-9]+[kM]?)\\(Index([0-9])\\)")) {
         nlist = parse_nlist(sm[1].str());
         int no = std::stoi(sm[2].str());
-        FAISS_ASSERT(no >= 0 && no < parenthesis_indexes.size());
+        FAISS_ASSERT(
+                no >= 0 &&
+                static_cast<size_t>(no) < parenthesis_indexes.size());
         return parenthesis_indexes[no].release();
     }
 
@@ -340,9 +377,11 @@ IndexIVF* parse_IndexIVF(
     if (match("FlatDedup")) {
         return new IndexIVFFlatDedup(get_q(), d, nlist, mt, own_il);
     }
-    if (match("FlatPanorama([0-9]+)?")) {
+    if (match("FlatPanorama([0-9]+)?(_([0-9]+))?")) {
         int nlevels = mres_to_int(sm[1], 8); // default to 8 levels
-        return new IndexIVFFlatPanorama(get_q(), d, nlist, nlevels, mt, own_il);
+        int bs = mres_to_int(sm[3], 128);
+        return new IndexIVFFlatPanorama(
+                get_q(), d, nlist, nlevels, mt, own_il, bs);
     }
     if (match(sq_pattern)) {
         return new IndexIVFScalarQuantizer(
@@ -588,6 +627,9 @@ SVSStorageKind parse_lvq(const std::string& lvq_string) {
     if (lvq_string == "LVQ4x8") {
         return SVSStorageKind::SVS_LVQ4x8;
     }
+    if (lvq_string == "LVQ8x0") {
+        return SVSStorageKind::SVS_LVQ8x0;
+    }
     FAISS_ASSERT(false && "not supported SVS LVQ level");
 }
 
@@ -619,28 +661,43 @@ Index* parse_svs_datatype(
         if (index_type == "Flat") {
             return new IndexSVSFlat(d, mt);
         }
-        FAISS_ASSERT(false && "Unspported SVS index type");
+        if (index_type == "IVF") {
+            return new IndexSVSIVF(d, std::stoul(arg_string), mt);
+        }
+        FAISS_ASSERT(false && "Unsupported SVS index type");
     }
     if (re_match(datatype_string, "FP16", sm)) {
         if (index_type == "Vamana") {
             return new IndexSVSVamana(
                     d, std::stoul(arg_string), mt, SVSStorageKind::SVS_FP16);
         }
-        FAISS_ASSERT(false && "Unspported SVS index type for Float16");
+        if (index_type == "IVF") {
+            return new IndexSVSIVF(
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_FP16);
+        }
+        FAISS_ASSERT(false && "Unsupported SVS index type for Float16");
     }
     if (re_match(datatype_string, "SQI8", sm)) {
         if (index_type == "Vamana") {
             return new IndexSVSVamana(
                     d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
         }
-        FAISS_ASSERT(false && "Unspported SVS index type for SQI8");
+        if (index_type == "IVF") {
+            return new IndexSVSIVF(
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+        }
+        FAISS_ASSERT(false && "Unsupported SVS index type for SQI8");
     }
     if (re_match(datatype_string, "(LVQ[0-9]+x[0-9]+)", sm)) {
         if (index_type == "Vamana") {
             return new IndexSVSVamanaLVQ(
                     d, std::stoul(arg_string), mt, parse_lvq(sm[0].str()));
         }
-        FAISS_ASSERT(false && "Unspported SVS index type for LVQ");
+        if (index_type == "IVF") {
+            return new IndexSVSIVFLVQ(
+                    d, std::stoul(arg_string), mt, parse_lvq(sm[0].str()));
+        }
+        FAISS_ASSERT(false && "Unsupported SVS index type for LVQ");
     }
     if (re_match(datatype_string, "(LeanVec[0-9]+x[0-9]+)(_[0-9]+)?", sm)) {
         std::string leanvec_d_string =
@@ -655,7 +712,15 @@ Index* parse_svs_datatype(
                     leanvec_d,
                     parse_leanvec(sm[1].str()));
         }
-        FAISS_ASSERT(false && "Unspported SVS index type for LeanVec");
+        if (index_type == "IVF") {
+            return new IndexSVSIVFLeanVec(
+                    d,
+                    std::stoul(arg_string),
+                    mt,
+                    leanvec_d,
+                    parse_leanvec(sm[1].str()));
+        }
+        FAISS_ASSERT(false && "Unsupported SVS index type for LeanVec");
     }
     return nullptr;
 }
@@ -675,7 +740,10 @@ Index* parse_IndexSVS(const std::string& code_string, int d, MetricType mt) {
                 "Vamana", degree_string, datatype_string, d, mt);
     }
     if (re_match(code_string, "IVF([0-9]+)(,.+)?", sm)) {
-        FAISS_ASSERT(false && "Unspported SVS index type");
+        std::string nlist_string = sm[1].str();
+        std::string datatype_string =
+                sm[2].length() > 0 ? sm[2].str().substr(1) : "";
+        return parse_svs_datatype("IVF", nlist_string, datatype_string, d, mt);
     }
     return nullptr;
 }
@@ -964,7 +1032,7 @@ std::unique_ptr<Index> index_factory_sub(
         int i0, i1;
         find_matching_parentheses(description, i0, i1, begin);
         std::string sub_description = description.substr(i0 + 1, i1 - i0 - 1);
-        int no = parenthesis_indexes.size();
+        size_t no = parenthesis_indexes.size();
         parenthesis_indexes.push_back(
                 index_factory_sub(d, sub_description, metric));
         description = description.substr(0, i0 + 1) + "Index" +

data/vendor/faiss/faiss/index_io.h

@@ -13,6 +13,8 @@
 #include <cstdio>
 #include <memory>
 
+#include <faiss/impl/platform_macros.h>
+
 /** I/O functions can read/write to a filename, a file handle or to an
  * object that abstracts the medium.
  *
@@ -68,6 +70,8 @@ const int IO_FLAG_MMAP = IO_FLAG_SKIP_IVF_DATA | 0x646f0000;
 //   after OnDiskInvertedLists get properly updated.
 const int IO_FLAG_MMAP_IFC = 1 << 9;
 
+FAISS_API extern bool index_read_warn_on_null_invlists;
+
 Index* read_index(const char* fname, int io_flags = 0);
 Index* read_index(FILE* f, int io_flags = 0);
 Index* read_index(IOReader* reader, int io_flags = 0);
@@ -113,6 +117,26 @@ std::unique_ptr<InvertedLists> read_InvertedLists_up(
         IOReader* reader,
         int io_flags = 0);
 
+// Returns the current deserialization loop limit.
+// When nonzero, deserialization rejects loop-driving fields (nlist,
+// nsplits, VT chain length, nhash, etc.) that exceed this value.
+// Default: 0 (no limit).
+size_t get_deserialization_loop_limit();
+
+// Sets the deserialization loop limit.
+// NOT thread-safe: set before any concurrent deserialization calls
+// and do not modify while deserialization is in progress on other threads.
+void set_deserialization_loop_limit(size_t value);
+
+// Returns the maximum number of bytes that a single READVECTOR call
+// may allocate.  Default: 1 TB (1 << 40).
+size_t get_deserialization_vector_byte_limit();
+
+// Sets the per-vector byte limit for deserialization.
+// NOT thread-safe: set before any concurrent deserialization calls
+// and do not modify while deserialization is in progress on other threads.
+void set_deserialization_vector_byte_limit(size_t value);
+
 } // namespace faiss
 
 #endif

data/vendor/faiss/faiss/invlists/BlockInvertedLists.cpp

@@ -5,6 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <faiss/index_io.h>
 #include <faiss/invlists/BlockInvertedLists.h>
 
 #include <memory>
@@ -19,23 +20,25 @@
 namespace faiss {
 
 BlockInvertedLists::BlockInvertedLists(
-        size_t nlist,
-        size_t n_per_block,
-        size_t block_size)
-        : InvertedLists(nlist, InvertedLists::INVALID_CODE_SIZE),
-          n_per_block(n_per_block),
-          block_size(block_size) {
-    ids.resize(nlist);
-    codes.resize(nlist);
+        size_t nlist_in,
+        size_t n_per_block_in,
+        size_t block_size_in)
+        : InvertedLists(nlist_in, InvertedLists::INVALID_CODE_SIZE),
+          n_per_block(n_per_block_in),
+          block_size(block_size_in) {
+    ids.resize(nlist_in);
+    codes.resize(nlist_in);
 }
 
-BlockInvertedLists::BlockInvertedLists(size_t nlist, const CodePacker* packer)
-        : InvertedLists(nlist, InvertedLists::INVALID_CODE_SIZE),
-          n_per_block(packer->nvec),
-          block_size(packer->block_size),
-          packer(packer) {
-    ids.resize(nlist);
-    codes.resize(nlist);
+BlockInvertedLists::BlockInvertedLists(
+        size_t nlist_in,
+        const CodePacker* packer_in)
+        : InvertedLists(nlist_in, InvertedLists::INVALID_CODE_SIZE),
+          n_per_block(packer_in->nvec),
+          block_size(packer_in->block_size),
+          packer(packer_in) {
+    ids.resize(nlist_in);
+    codes.resize(nlist_in);
 }
 
 BlockInvertedLists::BlockInvertedLists()
@@ -84,7 +87,7 @@ const uint8_t* BlockInvertedLists::get_codes(size_t list_no) const {
 size_t BlockInvertedLists::remove_ids(const IDSelector& sel) {
     idx_t nremove = 0;
 #pragma omp parallel for reduction(+ : nremove)
-    for (idx_t i = 0; i < nlist; i++) {
+    for (idx_t i = 0; i < static_cast<idx_t>(nlist); i++) {
         std::vector<uint8_t> buffer(packer->code_size);
         idx_t l = ids[i].size(), j = 0;
         while (j < l) {
@@ -165,16 +168,63 @@ InvertedLists* BlockInvertedListsIOHook::read(IOReader* f, int /* io_flags */)
         const {
     auto il = std::make_unique<BlockInvertedLists>();
     READ1(il->nlist);
+    {
+        auto limit_ = get_deserialization_loop_limit();
+        if (limit_ > 0) {
+            FAISS_THROW_IF_NOT_FMT(
+                    static_cast<size_t>(il->nlist) <= limit_,
+                    "BlockInvertedLists nlist=%zd exceeds "
+                    "deserialization_loop_limit of %zd",
+                    static_cast<size_t>(il->nlist),
+                    limit_);
+        }
+    }
     READ1(il->code_size);
     READ1(il->n_per_block);
     READ1(il->block_size);
 
+    {
+        auto limit = get_deserialization_loop_limit();
+        if (limit > 0) {
+            FAISS_THROW_IF_NOT_FMT(
+                    il->nlist <= limit,
+                    "BlockInvertedLists nlist=%zd exceeds "
+                    "deserialization_loop_limit of %zd",
+                    il->nlist,
+                    limit);
+        }
+    }
+
+    FAISS_THROW_IF_NOT_FMT(
+            il->n_per_block > 0,
+            "invalid BlockInvertedLists n_per_block %zd (must be > 0)",
+            il->n_per_block);
+    FAISS_THROW_IF_NOT_FMT(
+            il->block_size > 0,
+            "invalid BlockInvertedLists block_size %zd (must be > 0)",
+            il->block_size);
+
     il->ids.resize(il->nlist);
     il->codes.resize(il->nlist);
 
     for (size_t i = 0; i < il->nlist; i++) {
         READVECTOR(il->ids[i]);
         READVECTOR(il->codes[i]);
+        size_t n_ids = il->ids[i].size();
+        size_t n_block = (n_ids + il->n_per_block - 1) / il->n_per_block;
+        size_t expected_codes_size = mul_no_overflow(
+                n_block, il->block_size, "BlockInvertedLists codes");
+        FAISS_THROW_IF_NOT_FMT(
+                il->codes[i].size() == expected_codes_size,
+                "BlockInvertedLists list %zd: codes size %zd does not "
+                "match expected %zd (ids=%zd, n_per_block=%zd, "
+                "block_size=%zd)",
+                i,
+                il->codes[i].size(),
+                expected_codes_size,
+                n_ids,
+                il->n_per_block,
+                il->block_size);
     }
 
     return il.release();

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -50,14 +50,15 @@ void DirectMap::set_type(
         InvertedLists::ScopedIds idlist(invlists, key);
 
         if (new_type == Array) {
-            for (long ofs = 0; ofs < list_size; ofs++) {
+            for (size_t ofs = 0; ofs < list_size; ofs++) {
                 FAISS_THROW_IF_NOT_MSG(
-                        0 <= idlist[ofs] && idlist[ofs] < ntotal,
+                        0 <= idlist[ofs] &&
+                                static_cast<size_t>(idlist[ofs]) < ntotal,
                         "direct map supported only for sequential ids");
                 array[idlist[ofs]] = lo_build(key, ofs);
             }
         } else if (new_type == Hashtable) {
-            for (long ofs = 0; ofs < list_size; ofs++) {
+            for (size_t ofs = 0; ofs < list_size; ofs++) {
                 hashtable[idlist[ofs]] = lo_build(key, ofs);
             }
         }
@@ -71,7 +72,9 @@ void DirectMap::clear() {
 
 idx_t DirectMap::get(idx_t key) const {
     if (type == Array) {
-        FAISS_THROW_IF_NOT_MSG(key >= 0 && key < array.size(), "invalid key");
+        FAISS_THROW_IF_NOT_MSG(
+                key >= 0 && static_cast<size_t>(key) < array.size(),
+                "invalid key");
         idx_t lo = array[key];
         FAISS_THROW_IF_NOT_MSG(lo >= 0, "-1 entry in direct_map");
         return lo;
@@ -111,8 +114,14 @@ void DirectMap::check_can_add(const idx_t* ids) {
 
 /********************* DirectMapAdd implementation */
 
-DirectMapAdd::DirectMapAdd(DirectMap& direct_map, size_t n, const idx_t* xids)
-        : direct_map(direct_map), type(direct_map.type), n(n), xids(xids) {
+DirectMapAdd::DirectMapAdd(
+        DirectMap& direct_map_in,
+        size_t n_in,
+        const idx_t* xids_in)
+        : direct_map(direct_map_in),
+          type(direct_map_in.type),
+          n(n_in),
+          xids(xids_in) {
     if (type == DirectMap::Array) {
         FAISS_THROW_IF_NOT(xids == nullptr);
         ntotal = direct_map.array.size();
@@ -133,7 +142,7 @@ void DirectMapAdd::add(size_t i, idx_t list_no, size_t ofs) {
 
 DirectMapAdd::~DirectMapAdd() {
     if (type == DirectMap::Hashtable) {
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             idx_t id = xids ? xids[i] : ntotal + i;
             direct_map.hashtable[id] = all_ofs[i];
         }
@@ -158,7 +167,7 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists* invlists) {
         }
         // exhaustive scan of IVF
 #pragma omp parallel for
-        for (idx_t i = 0; i < nlist; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(nlist); i++) {
             idx_t l0 = invlists->list_size(i), l = l0, j = 0;
             ScopedIds idsi(invlists, i);
             while (j < l) {
@@ -177,7 +186,7 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists* invlists) {
         }
         // this will not run well in parallel on ondisk because of
         // possible shrinks
-        for (idx_t i = 0; i < nlist; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(nlist); i++) {
             if (toremove[i] > 0) {
                 nremove += toremove[i];
                 invlists->resize(i, invlists->list_size(i) - toremove[i]);
@@ -192,13 +201,13 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists* invlists) {
         FAISS_THROW_IF_NOT_MSG(
                 sela, "remove with hashtable works only with IDSelectorArray");
 
-        for (idx_t i = 0; i < sela->n; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(sela->n); i++) {
             idx_t id = sela->ids[i];
             auto res = hashtable.find(id);
             if (res != hashtable.end()) {
                 size_t list_no = lo_listno(res->second);
                 size_t offset = lo_offset(res->second);
-                idx_t last = invlists->list_size(list_no) - 1;
+                size_t last = invlists->list_size(list_no) - 1;
                 hashtable.erase(res);
                 if (offset < last) {
                     idx_t last_id = invlists->get_single_id(list_no, last);
@@ -231,16 +240,17 @@ void DirectMap::update_codes(
 
     size_t code_size = invlists->code_size;
 
-    for (size_t i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
         idx_t id = ids[i];
         FAISS_THROW_IF_NOT_MSG(
-                0 <= id && id < array.size(), "id to update out of range");
+                0 <= id && static_cast<size_t>(id) < array.size(),
+                "id to update out of range");
         { // remove old one
             idx_t dm = array[id];
             int64_t ofs = lo_offset(dm);
             int64_t il = lo_listno(dm);
             size_t l = invlists->list_size(il);
-            if (ofs != l - 1) { // move l - 1 to ofs
+            if (static_cast<size_t>(ofs) != l - 1) { // move l - 1 to ofs
                 int64_t id2 = invlists->get_single_id(il, l - 1);
                 array[id2] = lo_build(il, ofs);
                 invlists->update_entry(

data/vendor/faiss/faiss/invlists/DirectMap.h

@@ -37,9 +37,10 @@ inline uint64_t lo_offset(uint64_t lo) {
  */
 struct DirectMap {
     enum Type {
-        NoMap = 0,    // default
-        Array = 1,    // sequential ids (only for add, no add_with_ids)
-        Hashtable = 2 // arbitrary ids
+        NoMap,     // default
+        Array,     // sequential ids (only for add, no add_with_ids)
+        Hashtable, // arbitrary ids
+        DMT_count
     };
     Type type;