faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/impl/index_read_utils.h

@@ -29,7 +29,7 @@ ArrayInvertedLists* set_array_invlist(
         IndexIVF* ivf,
         std::vector<std::vector<idx_t>>& ids);
 void read_ProductQuantizer(ProductQuantizer* pq, IOReader* f);
-void read_ScalarQuantizer(ScalarQuantizer* ivsc, IOReader* f);
+void read_ScalarQuantizer(ScalarQuantizer* ivsc, IOReader* f, const Index& idx);
 
 } // namespace faiss
 

data/vendor/faiss/faiss/impl/index_write.cpp

@@ -53,6 +53,9 @@
 #ifdef FAISS_ENABLE_SVS
 #include <faiss/impl/svs_io.h>
 #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>
@@ -269,11 +272,20 @@ void write_InvertedLists(const InvertedLists* ils, IOWriter* f) {
     } else if (
             const auto& ailp =
                     dynamic_cast<const ArrayInvertedListsPanorama*>(ils)) {
-        uint32_t h = fourcc("ilpn");
-        WRITE1(h);
-        WRITE1(ailp->nlist);
-        WRITE1(ailp->code_size);
-        WRITE1(ailp->n_levels);
+        if (ailp->pano.batch_size == Panorama::kDefaultBatchSize) {
+            uint32_t h = fourcc("ilpn");
+            WRITE1(h);
+            WRITE1(ailp->nlist);
+            WRITE1(ailp->code_size);
+            WRITE1(ailp->n_levels);
+        } else {
+            uint32_t h = fourcc("ilp2");
+            WRITE1(h);
+            WRITE1(ailp->nlist);
+            WRITE1(ailp->code_size);
+            WRITE1(ailp->n_levels);
+            WRITE1(ailp->pano.batch_size);
+        }
         uint32_t list_type = fourcc("full");
         WRITE1(list_type);
         std::vector<size_t> sizes;
@@ -648,13 +660,13 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
 
         write_InvertedLists(ivaqfs->invlists, f);
     } else if (
-            const ResidualCoarseQuantizer* idxr_2 =
+            const ResidualCoarseQuantizer* idxrcq =
                     dynamic_cast<const ResidualCoarseQuantizer*>(idx)) {
         uint32_t h = fourcc("ImRQ");
         WRITE1(h);
         write_index_header(idx, f);
-        write_ResidualQuantizer(&idxr_2->rq, f);
-        WRITE1(idxr_2->beam_factor);
+        write_ResidualQuantizer(&idxrcq->rq, f);
+        WRITE1(idxrcq->beam_factor);
     } else if (
             const Index2Layer* idxp_2 = dynamic_cast<const Index2Layer*>(idx)) {
         uint32_t h = fourcc("Ix2L");
@@ -707,10 +719,18 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
     } else if (
             const IndexIVFFlatPanorama* ivfp =
                     dynamic_cast<const IndexIVFFlatPanorama*>(idx)) {
-        uint32_t h = fourcc("IwPn");
-        WRITE1(h);
-        write_ivf_header(ivfp, f);
-        WRITE1(ivfp->n_levels);
+        if (ivfp->batch_size == Panorama::kDefaultBatchSize) {
+            uint32_t h = fourcc("IwPn");
+            WRITE1(h);
+            write_ivf_header(ivfp, f);
+            WRITE1(ivfp->n_levels);
+        } else {
+            uint32_t h = fourcc("IwP2");
+            WRITE1(h);
+            write_ivf_header(ivfp, f);
+            WRITE1(ivfp->n_levels);
+            WRITE1(ivfp->batch_size);
+        }
         write_InvertedLists(ivfp->invlists, f);
     } else if (
             const IndexIVFFlat* ivfl_2 =
@@ -1007,6 +1027,8 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
             h = fourcc("ILVQ"); // LVQ
         } else if (lean != nullptr) {
             h = fourcc("ISVL"); // LeanVec
+        } else if (svs->stored_vectors_valid && !svs->stored_vectors.empty()) {
+            h = fourcc("ISV2"); // uncompressed + stored_vectors
         } else {
             h = fourcc("ISVD"); // uncompressed
         }
@@ -1049,6 +1071,10 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
                 os.flush();
             }
         }
+
+        if (h == fourcc("ISV2")) {
+            WRITEVECTOR(svs->stored_vectors);
+        }
     } else if (
             const IndexSVSFlat* svs = dynamic_cast<const IndexSVSFlat*>(idx)) {
         uint32_t h = fourcc("ISVF");
@@ -1065,6 +1091,62 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
             svs->serialize_impl(os);
             os.flush();
         }
+    } else if (
+            const IndexSVSIVF* svs_ivf =
+                    dynamic_cast<const IndexSVSIVF*>(idx)) {
+        uint32_t h;
+        auto* lvq = dynamic_cast<const IndexSVSIVFLVQ*>(svs_ivf);
+        auto* lean = dynamic_cast<const IndexSVSIVFLeanVec*>(svs_ivf);
+        if (lvq != nullptr) {
+            h = fourcc("ISIQ"); // IndexSVSIVFLVQ
+        } else if (lean != nullptr) {
+            h = fourcc("ISIL"); // IndexSVSIVFLeanVec
+        } else {
+            h = fourcc("ISID"); // IndexSVSIVF
+        }
+
+        WRITE1(h);
+        write_index_header(svs_ivf, f);
+        WRITE1(svs_ivf->num_centroids);
+        WRITE1(svs_ivf->minibatch_size);
+        WRITE1(svs_ivf->num_iterations);
+        WRITE1(svs_ivf->is_hierarchical);
+        WRITE1(svs_ivf->training_fraction);
+        WRITE1(svs_ivf->hierarchical_level1_clusters);
+        WRITE1(svs_ivf->seed);
+        WRITE1(svs_ivf->n_probes);
+        WRITE1(svs_ivf->k_reorder);
+        WRITE1(svs_ivf->num_threads);
+        WRITE1(svs_ivf->intra_query_threads);
+        WRITE1(svs_ivf->storage_kind);
+        WRITE1(svs_ivf->is_static);
+
+        if (lean != nullptr) {
+            WRITE1(lean->leanvec_d);
+        }
+
+        bool initialized = (svs_ivf->impl != nullptr);
+        WRITE1(initialized);
+        if (initialized) {
+            faiss::BufferedIOWriter bwr(f);
+            faiss::svs_io::WriterStreambuf wbuf(&bwr);
+            std::ostream os(&wbuf);
+            svs_ivf->serialize_impl(os);
+            os.flush();
+        }
+
+        if (lean != nullptr) {
+            // Store training data info
+            bool trained = (lean->training_data != nullptr);
+            WRITE1(trained);
+            if (trained) {
+                faiss::BufferedIOWriter bwr(f);
+                faiss::svs_io::WriterStreambuf wbuf(&bwr);
+                std::ostream os(&wbuf);
+                lean->serialize_training_data(os);
+                os.flush();
+            }
+        }
     }
 #endif // FAISS_ENABLE_SVS
     else if (
@@ -1165,7 +1247,7 @@ static void write_binary_multi_hash_map(
         size_t ntotal,
         IOWriter* f) {
     int id_bits = 0;
-    while ((ntotal > ((idx_t)1 << id_bits))) {
+    while ((ntotal > (size_t(1) << id_bits))) {
         id_bits++;
     }
     WRITE1(id_bits);

data/vendor/faiss/faiss/impl/io.cpp

@@ -134,14 +134,14 @@ int FileIOWriter::filedescriptor() {
  * IO buffer
  ***********************************************************************/
 
-BufferedIOReader::BufferedIOReader(IOReader* reader, size_t bsz)
-        : reader(reader),
-          bsz(bsz),
+BufferedIOReader::BufferedIOReader(IOReader* reader_in, size_t bsz_in)
+        : reader(reader_in),
+          bsz(bsz_in),
           ofs(0),
           ofs2(0),
           b0(0),
           b1(0),
-          buffer(bsz) {}
+          buffer(bsz_in) {}
 
 size_t BufferedIOReader::operator()(void* ptr, size_t unitsize, size_t nitems) {
     size_t size = unitsize * nitems;
@@ -184,8 +184,8 @@ size_t BufferedIOReader::operator()(void* ptr, size_t unitsize, size_t nitems) {
     return nb / unitsize;
 }
 
-BufferedIOWriter::BufferedIOWriter(IOWriter* writer, size_t bsz)
-        : writer(writer), bsz(bsz), ofs2(0), b0(0), buffer(bsz) {}
+BufferedIOWriter::BufferedIOWriter(IOWriter* writer_in, size_t bsz_in)
+        : writer(writer_in), bsz(bsz_in), ofs2(0), b0(0), buffer(bsz_in) {}
 
 size_t BufferedIOWriter::operator()(
         const void* ptr,

data/vendor/faiss/faiss/impl/io_macros.h

@@ -17,6 +17,10 @@
  * always called f and thus is not passed in as a macro parameter.
  **************************************************************/
 
+namespace faiss {
+size_t get_deserialization_vector_byte_limit();
+} // namespace faiss
+
 #define READANDCHECK(ptr, n)                         \
     {                                                \
         size_t ret = (*f)(ptr, sizeof(*(ptr)), n);   \
@@ -37,14 +41,24 @@
         READ1(x);           \
     }
 
-// will fail if we write 256G of data at once...
-#define READVECTOR(vec)                                              \
-    {                                                                \
-        size_t size;                                                 \
-        READANDCHECK(&size, 1);                                      \
-        FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
-        (vec).resize(size);                                          \
-        READANDCHECK((vec).data(), size);                            \
+// Rejects vectors whose total allocation would exceed the configurable
+// byte limit (default 1 TB).
+#define READVECTOR(vec)                                                  \
+    {                                                                    \
+        size_t size;                                                     \
+        READANDCHECK(&size, 1);                                          \
+        FAISS_THROW_IF_NOT(                                              \
+                size >= 0 &&                                             \
+                size < (faiss::get_deserialization_vector_byte_limit() / \
+                        sizeof(*(vec).data())));                         \
+        FAISS_THROW_IF_NOT_FMT(                                          \
+                size <= SIZE_MAX / sizeof((vec)[0]),                     \
+                "READVECTOR: size %zu would overflow for element "       \
+                "size %zu",                                              \
+                size,                                                    \
+                sizeof((vec)[0]));                                       \
+        (vec).resize(size);                                              \
+        READANDCHECK((vec).data(), size);                                \
     }
 
 #define WRITEANDCHECK(ptr, n)                         \
@@ -78,12 +92,15 @@
         WRITEANDCHECK((vec).data(), size * 4);     \
     }
 
-#define READXBVECTOR(vec)                                            \
-    {                                                                \
-        size_t size;                                                 \
-        READANDCHECK(&size, 1);                                      \
-        FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
-        size *= 4;                                                   \
-        (vec).resize(size);                                          \
-        READANDCHECK((vec).data(), size);                            \
+#define READXBVECTOR(vec)                                                \
+    {                                                                    \
+        size_t size;                                                     \
+        READANDCHECK(&size, 1);                                          \
+        FAISS_THROW_IF_NOT(                                              \
+                size >= 0 &&                                             \
+                size < (faiss::get_deserialization_vector_byte_limit() / \
+                        (4 * sizeof(*(vec).data()))));                   \
+        size *= 4;                                                       \
+        (vec).resize(size);                                              \
+        READANDCHECK((vec).data(), size);                                \
     }

data/vendor/faiss/faiss/impl/kmeans1d.cpp

@@ -48,12 +48,12 @@ void interpolate(
         const LookUpFunc& lookup,
         idx_t* argmins) {
     std::unordered_map<idx_t, idx_t> idx_to_col;
-    for (idx_t idx = 0; idx < cols.size(); ++idx) {
+    for (size_t idx = 0; idx < cols.size(); ++idx) {
         idx_to_col[cols[idx]] = idx;
     }
 
     idx_t start = 0;
-    for (idx_t r = 0; r < rows.size(); r += 2) {
+    for (size_t r = 0; r < rows.size(); r += 2) {
         idx_t row = rows[r];
         idx_t end = cols.size() - 1;
         if (r < rows.size() - 1) {
@@ -107,7 +107,7 @@ void smawk_impl(
 
     // call recursively on odd-indexed rows
     std::vector<idx_t> odd_rows;
-    for (idx_t i = 1; i < rows.size(); i += 2) {
+    for (size_t i = 1; i < rows.size(); i += 2) {
         odd_rows.push_back(rows[i]);
     }
     smawk_impl(odd_rows, cols, lookup, argmins);
@@ -175,10 +175,10 @@ class Matrix {
     idx_t ncols;
 
    public:
-    Matrix(idx_t nrows, idx_t ncols) {
-        this->nrows = nrows;
-        this->ncols = ncols;
-        data.resize(nrows * ncols);
+    Matrix(idx_t nrows_in, idx_t ncols_in) {
+        this->nrows = nrows_in;
+        this->ncols = ncols_in;
+        data.resize(nrows_in * ncols_in);
     }
 
     inline T& at(idx_t i, idx_t j) {
@@ -240,14 +240,14 @@ double kmeans1d(const float* x, size_t n, size_t nclusters, float* centroids) {
     Matrix<float> D(nclusters, n);
     Matrix<idx_t> T(nclusters, n);
 
-    for (idx_t m = 0; m < n; m++) {
+    for (idx_t m = 0; m < static_cast<idx_t>(n); m++) {
         D.at(0, m) = CC(0, m);
         T.at(0, m) = 0;
     }
 
     std::vector<idx_t> indices(nclusters, 0);
 
-    for (idx_t k = 1; k < nclusters; ++k) {
+    for (idx_t k = 1; k < static_cast<idx_t>(nclusters); ++k) {
         // we define C here
         auto C = [&D, &CC, &k](idx_t m, idx_t i) {
             if (i == 0) {
@@ -259,7 +259,7 @@ double kmeans1d(const float* x, size_t n, size_t nclusters, float* centroids) {
 
         std::vector<idx_t> argmins(n); // argmin of each row
         smawk(n, n, C, argmins.data());
-        for (idx_t m = 0; m < argmins.size(); m++) {
+        for (size_t m = 0; m < argmins.size(); m++) {
             idx_t idx = argmins[m];
             D.at(k, m) = C(m, idx);
             T.at(k, m) = idx;

data/vendor/faiss/faiss/impl/lattice_Zn.cpp

@@ -41,7 +41,7 @@ struct Comb {
     std::vector<uint64_t> tab; // Pascal's triangle
     int nmax;
 
-    explicit Comb(int nmax) : nmax(nmax) {
+    explicit Comb(int nmax_in) : nmax(nmax_in) {
         tab.resize(nmax * nmax, 0);
         tab[0] = 1;
         for (int i = 1; i < nmax; i++) {
@@ -172,9 +172,9 @@ void repeats_decode_64(
 
 } // anonymous namespace
 
-Repeats::Repeats(int dim, const float* c) : dim(dim) {
+Repeats::Repeats(int dim_in, const float* c) : dim(dim_in) {
     for (int i = 0; i < dim; i++) {
-        int j = 0;
+        size_t j = 0;
         for (;;) {
             if (j == repeats.size()) {
                 repeats.push_back(Repeat{c[i], 1});
@@ -192,7 +192,7 @@ Repeats::Repeats(int dim, const float* c) : dim(dim) {
 uint64_t Repeats::count() const {
     uint64_t accu = 1;
     int remain = dim;
-    for (int i = 0; i < repeats.size(); i++) {
+    for (size_t i = 0; i < repeats.size(); i++) {
         accu *= comb(remain, repeats[i].n);
         remain -= repeats[i].n;
     }
@@ -275,7 +275,7 @@ void EnumeratedVectors::encode_multi(size_t n, const float* c, uint64_t* codes)
 #pragma omp parallel if (n > 1000)
     {
 #pragma omp for
-        for (int i = 0; i < n; i++) {
+        for (int64_t i = 0; i < static_cast<int64_t>(n); i++) {
             codes[i] = encode(c + i * dim);
         }
     }
@@ -286,7 +286,7 @@ void EnumeratedVectors::decode_multi(size_t n, const uint64_t* codes, float* c)
 #pragma omp parallel if (n > 1000)
     {
 #pragma omp for
-        for (int i = 0; i < n; i++) {
+        for (int64_t i = 0; i < static_cast<int64_t>(n); i++) {
             decode(codes[i], c + i * dim);
         }
     }
@@ -325,11 +325,11 @@ void EnumeratedVectors::find_nn(
  * ZnSphereSearch
  **********************************************************/
 
-ZnSphereSearch::ZnSphereSearch(int dim, int r2) : dimS(dim), r2(r2) {
+ZnSphereSearch::ZnSphereSearch(int dim, int r2_in) : dimS(dim), r2(r2_in) {
     FAISS_THROW_IF_NOT_MSG(
             dim > 0 && dim <= 64, "ZnSphereSearch: dim must be in [1, 64]");
     FAISS_THROW_IF_NOT_MSG(
-            r2 >= 0 && r2 <= 512,
+            r2_in >= 0 && r2_in <= 512,
             "ZnSphereSearch: r2 must be in [0, 512] to avoid"
             " excessive computation in sum_of_sq");
     voc = sum_of_sq(r2, int(ceil(sqrt(r2)) + 1), dim);
@@ -404,8 +404,8 @@ void ZnSphereSearch::search_multi(
  * ZnSphereCodec
  **********************************************************/
 
-ZnSphereCodec::ZnSphereCodec(int dim, int r2)
-        : ZnSphereSearch(dim, r2), EnumeratedVectors(dim) {
+ZnSphereCodec::ZnSphereCodec(int dim_in, int r2_in)
+        : ZnSphereSearch(dim_in, r2_in), EnumeratedVectors(dim_in) {
     nv = 0;
     for (int i = 0; i < natom; i++) {
         Repeats repeats(dim, &voc[i * dim]);
@@ -497,10 +497,10 @@ void ZnSphereCodecRec::set_nv_cum(int ld, int r2t, int r2a, uint64_t cum) {
     all_nv_cum[(ld * (r2 + 1) + r2t) * (r2 + 1) + r2a] = cum;
 }
 
-ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2)
-        : EnumeratedVectors(dim), r2(r2) {
+ZnSphereCodecRec::ZnSphereCodecRec(int dim_in, int r2_in)
+        : EnumeratedVectors(dim_in), r2(r2_in) {
     FAISS_THROW_IF_NOT_MSG(
-            dim > 0 && r2 >= 0, "invalid ZnSphereCodecRec parameters");
+            dim_in > 0 && r2_in >= 0, "invalid ZnSphereCodecRec parameters");
     log2_dim = 0;
     while (dim > (1 << log2_dim)) {
         log2_dim++;
@@ -533,13 +533,13 @@ ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2)
 
     for (int ld = 1; ld <= log2_dim; ld++) {
         for (int r2sub = 0; r2sub <= r2; r2sub++) {
-            uint64_t nv = 0;
+            uint64_t nv_acc = 0;
             for (int r2a = 0; r2a <= r2sub; r2a++) {
                 int r2b = r2sub - r2a;
-                set_nv_cum(ld, r2sub, r2a, nv);
-                nv += get_nv(ld - 1, r2a) * get_nv(ld - 1, r2b);
+                set_nv_cum(ld, r2sub, r2a, nv_acc);
+                nv_acc += get_nv(ld - 1, r2a) * get_nv(ld - 1, r2b);
             }
-            all_nv[ld * (r2 + 1) + r2sub] = nv;
+            all_nv[ld * (r2 + 1) + r2sub] = nv_acc;
         }
     }
     nv = get_nv(log2_dim, r2);
@@ -554,17 +554,31 @@ ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2)
     int cache_level = std::min(3, log2_dim - 1);
     decode_cache_ld = 0;
     assert(cache_level <= log2_dim);
+
     decode_cache.resize((r2 + 1));
 
+    // The decode cache stores total_cache_entries * dimsub floats.
+    // Cap at 2^27 total floats (~512 MB), aligned with the nv_cum
+    // memory cap above which also uses 2^27 entries.  The entry count
+    // grows as the number of lattice points in dimension
+    // 2^cache_level, which is O(r2^(dim/2)) -- much faster than the
+    // O(r2^2) growth of nv_cum.
+    size_t total_cache_entries = 0;
+    int dimsub = (1 << cache_level);
+
     for (int r2sub = 0; r2sub <= r2; r2sub++) {
         int ld = cache_level;
         uint64_t nvi = get_nv(ld, r2sub);
+        total_cache_entries += nvi;
+        FAISS_THROW_IF_NOT_MSG(
+                total_cache_entries <= (size_t(1) << 27) / dimsub,
+                "ZnSphereCodecRec: r2 too large, decode cache "
+                "would require excessive memory");
         std::vector<float>& cache = decode_cache[r2sub];
-        int dimsub = (1 << cache_level);
         cache.resize(nvi * dimsub);
         std::vector<float> c(dim);
         uint64_t code0 = get_nv_cum(cache_level + 1, r2, r2 - r2sub);
-        for (int i = 0; i < nvi; i++) {
+        for (uint64_t i = 0; i < nvi; i++) {
             decode(i + code0, c.data());
             memcpy(&cache[i * dimsub],
                    c.data() + dim - dimsub,
@@ -670,10 +684,10 @@ void ZnSphereCodecRec::decode(uint64_t code, float* c) const {
 }
 
 // if not use_rec, instantiate an arbitrary harmless znc_rec
-ZnSphereCodecAlt::ZnSphereCodecAlt(int dim, int r2)
-        : ZnSphereCodec(dim, r2),
-          use_rec((dim & (dim - 1)) == 0),
-          znc_rec(use_rec ? dim : 8, use_rec ? r2 : 14) {}
+ZnSphereCodecAlt::ZnSphereCodecAlt(int dim_in, int r2_in)
+        : ZnSphereCodec(dim_in, r2_in),
+          use_rec((dim_in & (dim_in - 1)) == 0),
+          znc_rec(use_rec ? dim_in : 8, use_rec ? r2_in : 14) {}
 
 uint64_t ZnSphereCodecAlt::encode(const float* x) const {
     if (!use_rec) {

data/vendor/faiss/faiss/impl/lattice_Zn.h

@@ -29,7 +29,7 @@ struct ZnSphereSearch {
     /// size dim * natom
     std::vector<float> voc;
 
-    ZnSphereSearch(int dim, int r2);
+    ZnSphereSearch(int dim, int r2_in);
 
     /// find nearest centroid. x does not need to be normalized
     float search(const float* x, float* c) const;
@@ -57,7 +57,7 @@ struct EnumeratedVectors {
     uint64_t nv;
     int dim;
 
-    explicit EnumeratedVectors(int dim) : nv(0), dim(dim) {}
+    explicit EnumeratedVectors(int dim_in) : nv(0), dim(dim_in) {}
 
     /// encode a vector from a collection
     virtual uint64_t encode(const float* x) const = 0;
@@ -98,7 +98,7 @@ struct Repeats {
     std::vector<Repeat> repeats;
 
     // initialize from a template of the atom.
-    Repeats(int dim = 0, const float* c = nullptr);
+    Repeats(int dim_in = 0, const float* c = nullptr);
 
     // count number of possible codes for this atom
     uint64_t count() const;
@@ -124,7 +124,7 @@ struct ZnSphereCodec : ZnSphereSearch, EnumeratedVectors {
     uint64_t nv;
     size_t code_size;
 
-    ZnSphereCodec(int dim, int r2);
+    ZnSphereCodec(int dim_in, int r2_in);
 
     uint64_t search_and_encode(const float* x) const;
 
@@ -146,7 +146,7 @@ struct ZnSphereCodecRec : EnumeratedVectors {
     int log2_dim;
     int code_size;
 
-    ZnSphereCodecRec(int dim, int r2);
+    ZnSphereCodecRec(int dim_in, int r2_in);
 
     uint64_t encode_centroid(const float* c) const;
 
@@ -176,7 +176,7 @@ struct ZnSphereCodecAlt : ZnSphereCodec {
     bool use_rec;
     ZnSphereCodecRec znc_rec;
 
-    ZnSphereCodecAlt(int dim, int r2);
+    ZnSphereCodecAlt(int dim_in, int r2_in);
 
     uint64_t encode(const float* x) const override;
 

data/vendor/faiss/faiss/impl/mapped_io.cpp

@@ -7,7 +7,7 @@
 
 #include <stdio.h>
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
 
 #include <fcntl.h>
 #include <sys/mman.h>
@@ -27,7 +27,7 @@
 
 namespace faiss {
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
 
 struct MmappedFileMappingOwner::PImpl {
     void* ptr = nullptr;
@@ -60,11 +60,11 @@ struct MmappedFileMappingOwner::PImpl {
         void* address = mmap(
                 nullptr, filesize, PROT_READ, MAP_SHARED, fileno(f.get()), 0);
         FAISS_THROW_IF_NOT_FMT(
-                address != nullptr, "could not mmap(): %s", strerror(errno));
+                address != MAP_FAILED, "could not mmap(): %s", strerror(errno));
 
         // btw, fd can be closed here
 
-        madvise(address, filesize, MADV_RANDOM);
+        (void)madvise(address, filesize, MADV_RANDOM);
 
         // save it
         ptr = address;
@@ -83,11 +83,11 @@ struct MmappedFileMappingOwner::PImpl {
         void* address =
                 mmap(nullptr, filesize, PROT_READ, MAP_SHARED, fileno(f), 0);
         FAISS_THROW_IF_NOT_FMT(
-                address != nullptr, "could not mmap(): %s", strerror(errno));
+                address != MAP_FAILED, "could not mmap(): %s", strerror(errno));
 
         // btw, fd can be closed here
 
-        madvise(address, filesize, MADV_RANDOM);
+        (void)madvise(address, filesize, MADV_RANDOM);
 
         // save it
         ptr = address;

data/vendor/faiss/faiss/impl/platform_macros.h

@@ -74,10 +74,6 @@ inline int __builtin_clzll(uint64_t x) {
 }
 #endif
 
-#define __builtin_popcount __popcnt
-#define __builtin_popcountl __popcnt64
-#define __builtin_popcountll __popcnt64
-
 #ifndef __clang__
 #define __m128i_u __m128i
 #define __m256i_u __m256i
@@ -110,9 +106,16 @@ inline int __builtin_clzll(uint64_t x) {
 // MSVC uses pragma pack instead of __attribute__((packed))
 // Use FAISS_PACK_STRUCTS_BEGIN/END to wrap packed structure definitions
 #define FAISS_PACKED
+#define FAISS_RESTRICT __restrict
 #define FAISS_PACK_STRUCTS_BEGIN __pragma(pack(push, 1))
 #define FAISS_PACK_STRUCTS_END __pragma(pack(pop))
 
+#ifdef SWIG
+#define FAISS_MAYBE_UNUSED
+#else
+#define FAISS_MAYBE_UNUSED [[maybe_unused]]
+#endif
+
 #else
 /*******************************************************
  * Linux and OSX
@@ -126,9 +129,13 @@ inline int __builtin_clzll(uint64_t x) {
 #ifdef SWIG
 #define ALIGNED(x)
 #define FAISS_PACKED
+#define FAISS_RESTRICT
+#define FAISS_MAYBE_UNUSED
 #else
 #define ALIGNED(x) __attribute__((aligned(x)))
 #define FAISS_PACKED __attribute__((packed))
+#define FAISS_RESTRICT __restrict
+#define FAISS_MAYBE_UNUSED [[maybe_unused]]
 #endif
 
 // On non-Windows, FAISS_PACKED handles packing, so these are no-ops