faiss 0.4.2 → 0.5.0

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

@@ -27,11 +27,13 @@
 #include <faiss/IndexIVFAdditiveQuantizer.h>
 #include <faiss/IndexIVFAdditiveQuantizerFastScan.h>
 #include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexIVFFlatPanorama.h>
 #include <faiss/IndexIVFIndependentQuantizer.h>
 #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,6 +43,7 @@
 #include <faiss/IndexPQFastScan.h>
 #include <faiss/IndexPreTransform.h>
 #include <faiss/IndexRaBitQ.h>
+#include <faiss/IndexRaBitQFastScan.h>
 #include <faiss/IndexRefine.h>
 #include <faiss/IndexRowwiseMinMax.h>
 #include <faiss/IndexScalarQuantizer.h>
@@ -68,7 +71,7 @@
  * or deprecated fields), the fourcc can be replaced. New code should
  * be able to read the old fourcc and fill in new classes.
  *
- * TODO: in this file, the read functions that encouter errors may
+ * TODO: in this file, the read functions that encounter errors may
  * leak memory.
  **************************************************************/
 
@@ -245,6 +248,33 @@ void write_InvertedLists(const InvertedLists* ils, IOWriter* f) {
     if (ils == nullptr) {
         uint32_t h = fourcc("il00");
         WRITE1(h);
+    } 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);
+        uint32_t list_type = fourcc("full");
+        WRITE1(list_type);
+        std::vector<size_t> sizes;
+        sizes.reserve(ailp->nlist);
+        for (size_t i = 0; i < ailp->nlist; i++) {
+            sizes.push_back(ailp->ids[i].size());
+        }
+        WRITEVECTOR(sizes);
+
+        // Write codes, ids, and cum_sums
+        for (size_t i = 0; i < ailp->nlist; i++) {
+            size_t n = ailp->ids[i].size();
+            if (n > 0) {
+                WRITEANDCHECK(ailp->codes[i].data(), ailp->codes[i].size());
+                WRITEANDCHECK(ailp->ids[i].data(), n);
+                WRITEANDCHECK(
+                        ailp->cum_sums[i].data(), ailp->cum_sums[i].size());
+            }
+        }
     } else if (
             const auto& ails = dynamic_cast<const ArrayInvertedLists*>(ils)) {
         uint32_t h = fourcc("ilar");
@@ -638,6 +668,14 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
             WRITEVECTOR(tab);
         }
         write_InvertedLists(ivfl->invlists, f);
+    } 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);
+        write_InvertedLists(ivfp->invlists, f);
     } else if (
             const IndexIVFFlat* ivfl_2 =
                     dynamic_cast<const IndexIVFFlat*>(idx)) {
@@ -848,7 +886,7 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
     } else if (
             const IndexRowwiseMinMax* imm =
                     dynamic_cast<const IndexRowwiseMinMax*>(idx)) {
-        // IndexRowwiseMinmaxFloat
+        // IndexRowwiseMinMaxFloat
         uint32_t h = fourcc("IRMf");
         WRITE1(h);
         write_index_header(imm, f);
@@ -856,11 +894,26 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
     } else if (
             const IndexRowwiseMinMaxFP16* imm_2 =
                     dynamic_cast<const IndexRowwiseMinMaxFP16*>(idx)) {
-        // IndexRowwiseMinmaxHalf
+        // IndexRowwiseMinMaxHalf
         uint32_t h = fourcc("IRMh");
         WRITE1(h);
         write_index_header(imm_2, f);
         write_index(imm_2->index, f);
+    } else if (
+            const IndexRaBitQFastScan* idxqfs =
+                    dynamic_cast<const IndexRaBitQFastScan*>(idx)) {
+        uint32_t h = fourcc("Irfs");
+        WRITE1(h);
+        write_index_header(idx, f);
+        write_RaBitQuantizer(&idxqfs->rabitq, f);
+        WRITEVECTOR(idxqfs->center);
+        WRITE1(idxqfs->qb);
+        WRITEVECTOR(idxqfs->factors_storage);
+        WRITE1(idxqfs->bbs);
+        WRITE1(idxqfs->ntotal2);
+        WRITE1(idxqfs->M2);
+        WRITE1(idxqfs->code_size);
+        WRITEVECTOR(idxqfs->codes);
     } else if (
             const IndexRaBitQ* idxq = dynamic_cast<const IndexRaBitQ*>(idx)) {
         uint32_t h = fourcc("Ixrq");
@@ -881,6 +934,23 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
         WRITE1(ivrq->by_residual);
         WRITE1(ivrq->qb);
         write_InvertedLists(ivrq->invlists, f);
+    } else if (
+            const IndexIVFRaBitQFastScan* ivrqfs =
+                    dynamic_cast<const IndexIVFRaBitQFastScan*>(idx)) {
+        uint32_t h = fourcc("Iwrf");
+        WRITE1(h);
+        write_ivf_header(ivrqfs, f);
+        write_RaBitQuantizer(&ivrqfs->rabitq, f);
+        WRITE1(ivrqfs->by_residual);
+        WRITE1(ivrqfs->code_size);
+        WRITE1(ivrqfs->bbs);
+        WRITE1(ivrqfs->qbs2);
+        WRITE1(ivrqfs->M2);
+        WRITE1(ivrqfs->implem);
+        WRITE1(ivrqfs->qb);
+        WRITE1(ivrqfs->centered);
+        WRITEVECTOR(ivrqfs->factors_storage);
+        write_InvertedLists(ivrqfs->invlists, f);
     } else {
         FAISS_THROW_MSG("don't know how to serialize this type of index");
     }

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

@@ -74,7 +74,7 @@ FileIOReader::FileIOReader(const char* fname) {
 FileIOReader::~FileIOReader() {
     if (need_close) {
         int ret = fclose(f);
-        if (ret != 0) { // we cannot raise and exception in the destructor
+        if (ret != 0) { // we cannot raise an exception in the destructor
             fprintf(stderr,
                     "file %s close error: %s",
                     name.c_str(),
@@ -109,7 +109,7 @@ FileIOWriter::~FileIOWriter() {
     if (need_close) {
         int ret = fclose(f);
         if (ret != 0) {
-            // we cannot raise and exception in the destructor
+            // we cannot raise an exception in the destructor
             fprintf(stderr,
                     "file %s close error: %s",
                     name.c_str(),

data/vendor/faiss/faiss/impl/io.h

@@ -65,9 +65,9 @@ struct FileIOReader : IOReader {
     FILE* f = nullptr;
     bool need_close = false;
 
-    FileIOReader(FILE* rf);
+    explicit FileIOReader(FILE* rf);
 
-    FileIOReader(const char* fname);
+    explicit FileIOReader(const char* fname);
 
     ~FileIOReader() override;
 
@@ -80,9 +80,9 @@ struct FileIOWriter : IOWriter {
     FILE* f = nullptr;
     bool need_close = false;
 
-    FileIOWriter(FILE* wf);
+    explicit FileIOWriter(FILE* wf);
 
-    FileIOWriter(const char* fname);
+    explicit FileIOWriter(const char* fname);
 
     ~FileIOWriter() override;
 

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

@@ -141,7 +141,7 @@ void smawk(
 namespace {
 
 class CostCalculator {
-    // The reuslt would be inaccurate if we use float
+    // The result would be inaccurate if we use float
     std::vector<double> cumsum;
     std::vector<double> cumsum2;
 

data/vendor/faiss/faiss/impl/kmeans1d.h

@@ -41,7 +41,7 @@ void smawk(
  * @param n          input array length
  * @param nclusters  number of clusters
  * @param centroids  output centroids, size nclusters
- * @return  imbalancce factor
+ * @return  imbalance factor
  */
 double kmeans1d(const float* x, size_t n, size_t nclusters, float* centroids);
 

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

@@ -26,7 +26,7 @@ struct ZnSphereSearch {
     int dimS, r2;
     int natom;
 
-    /// size dim * ntatom
+    /// size dim * natom
     std::vector<float> voc;
 
     ZnSphereSearch(int dim, int r2);
@@ -138,7 +138,7 @@ struct ZnSphereCodec : ZnSphereSearch, EnumeratedVectors {
  *
  * Uses a recursive decomposition on the dimensions to encode
  * centroids found by the ZnSphereSearch. The codes are *not*
- * compatible with the ones of ZnSpehreCodec
+ * compatible with the ones of ZnSphereCodec
  */
 struct ZnSphereCodecRec : EnumeratedVectors {
     int r2;

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

@@ -33,7 +33,7 @@ struct MmappedFileMappingOwner::PImpl {
     void* ptr = nullptr;
     size_t ptr_size = 0;
 
-    PImpl(const std::string& filename) {
+    explicit PImpl(const std::string& filename) {
         auto f = std::unique_ptr<FILE, decltype(&fclose)>(
                 fopen(filename.c_str(), "r"), &fclose);
         FAISS_THROW_IF_NOT_FMT(
@@ -64,7 +64,7 @@ struct MmappedFileMappingOwner::PImpl {
         ptr_size = filesize;
     }
 
-    PImpl(FILE* f) {
+    explicit PImpl(FILE* f) {
         // get the size
         struct stat s;
         int status = fstat(fileno(f), &s);

data/vendor/faiss/faiss/impl/mapped_io.h

@@ -18,8 +18,8 @@ namespace faiss {
 
 // holds a memory-mapped region over a file
 struct MmappedFileMappingOwner : public MaybeOwnedVectorOwner {
-    MmappedFileMappingOwner(const std::string& filename);
-    MmappedFileMappingOwner(FILE* f);
+    explicit MmappedFileMappingOwner(const std::string& filename);
+    explicit MmappedFileMappingOwner(FILE* f);
     ~MmappedFileMappingOwner();
 
     void* data() const;
@@ -37,7 +37,8 @@ struct MappedFileIOReader : IOReader {
 
     size_t pos = 0;
 
-    MappedFileIOReader(const std::shared_ptr<MmappedFileMappingOwner>& owner);
+    explicit MappedFileIOReader(
+            const std::shared_ptr<MmappedFileMappingOwner>& owner);
 
     // perform a copy
     size_t operator()(void* ptr, size_t size, size_t nitems) override;

data/vendor/faiss/faiss/impl/maybe_owned_vector.h

@@ -51,7 +51,7 @@ struct MaybeOwnedVector {
     size_t c_size = 0;
 
     MaybeOwnedVector() = default;
-    MaybeOwnedVector(const size_t initial_size) {
+    explicit MaybeOwnedVector(const size_t initial_size) {
         is_owned = true;
 
         owned_data.resize(initial_size);
@@ -295,9 +295,16 @@ struct is_maybe_owned_vector : std::false_type {};
 template <typename T>
 struct is_maybe_owned_vector<MaybeOwnedVector<T>> : std::true_type {};
 
+// guard with c++-17 (maybe, it is available somewhere in
+// faiss/impl/platform.h?).
+// This allows headers to be included in c++11 code.
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+
 template <typename T>
 inline constexpr bool is_maybe_owned_vector_v = is_maybe_owned_vector<T>::value;
 
+#endif
+
 template <typename T>
 bool operator==(
         const MaybeOwnedVector<T>& lhs,

data/vendor/faiss/faiss/impl/pq4_fast_scan.cpp

@@ -49,7 +49,19 @@ void pq4_pack_codes(
         size_t nb,
         size_t bbs,
         size_t nsq,
-        uint8_t* blocks) {
+        uint8_t* blocks,
+        size_t code_stride) {
+    // Determine stride: use custom if provided, otherwise use legacy
+    // calculation
+    size_t actual_stride = (code_stride == 0) ? (M + 1) / 2 : code_stride;
+
+    // Input validation for custom stride
+    if (code_stride != 0) {
+        FAISS_THROW_IF_NOT_MSG(
+                code_stride >= (M + 1) / 2,
+                "Custom stride must be >= minimum code size");
+    }
+
     FAISS_THROW_IF_NOT(bbs % 32 == 0);
     FAISS_THROW_IF_NOT(nb % bbs == 0);
     FAISS_THROW_IF_NOT(nsq % 2 == 0);
@@ -72,7 +84,8 @@ void pq4_pack_codes(
             for (size_t i = 0; i < bbs; i += 32) {
                 std::array<uint8_t, 32> c, c0, c1;
                 get_matrix_column(
-                        codes, ntotal, (M + 1) / 2, i0 + i, sq / 2, c);
+                        codes, ntotal, actual_stride, i0 + i, sq / 2, c);
+
                 for (int j = 0; j < 32; j++) {
                     c0[j] = c[j] & 15;
                     c1[j] = c[j] >> 4;
@@ -97,7 +110,19 @@ void pq4_pack_codes_range(
         size_t i1,
         size_t bbs,
         size_t nsq,
-        uint8_t* blocks) {
+        uint8_t* blocks,
+        size_t code_stride) {
+    // Determine stride: use custom if provided, otherwise use legacy
+    // calculation
+    size_t actual_stride = (code_stride == 0) ? (M + 1) / 2 : code_stride;
+
+    // Input validation for custom stride
+    if (code_stride != 0) {
+        FAISS_THROW_IF_NOT_MSG(
+                code_stride >= (M + 1) / 2,
+                "Custom stride must be >= minimum code size");
+    }
+
 #ifdef FAISS_BIG_ENDIAN
     const uint8_t perm0[16] = {
             8, 0, 9, 1, 10, 2, 11, 3, 12, 4, 13, 5, 14, 6, 15, 7};
@@ -117,7 +142,8 @@ void pq4_pack_codes_range(
             for (size_t i = 0; i < bbs; i += 32) {
                 std::array<uint8_t, 32> c, c0, c1;
                 get_matrix_column(
-                        codes, i1 - i0, (M + 1) / 2, i_base + i, sq / 2, c);
+                        codes, i1 - i0, actual_stride, i_base + i, sq / 2, c);
+
                 for (int j = 0; j < 32; j++) {
                     c0[j] = c[j] & 15;
                     c1[j] = c[j] >> 4;

data/vendor/faiss/faiss/impl/pq4_fast_scan.h

@@ -34,9 +34,11 @@ struct SIMDResultHandler;
  * @param ntotal  number of input codes
  * @param nb      output number of codes (ntotal rounded up to a multiple of
  *                bbs)
- * @param nsq      number of sub-quantizers (=M rounded up to a muliple of 2)
+ * @param nsq      number of sub-quantizers (=M rounded up to a multiple of 2)
  * @param bbs     size of database blocks (multiple of 32)
  * @param blocks  output array, size nb * nsq / 2.
+ * @param code_stride  optional stride between consecutive codes (0 = use
+default (M + 1) / 2)
  */
 void pq4_pack_codes(
         const uint8_t* codes,
@@ -45,7 +47,8 @@ void pq4_pack_codes(
         size_t nb,
         size_t bbs,
         size_t nsq,
-        uint8_t* blocks);
+        uint8_t* blocks,
+        size_t code_stride = 0);
 
 /** Same as pack_codes but write in a given range of the output,
  * leaving the rest untouched. Assumes allocated entries are 0 on input.
@@ -54,6 +57,8 @@ void pq4_pack_codes(
  * @param i0      first output code to write
  * @param i1      last output code to write
  * @param blocks  output array, size at least ceil(i1 / bbs) * bbs * nsq / 2
+ * @param code_stride  optional stride between consecutive codes (0 = use
+ * default (M + 1) / 2)
  */
 void pq4_pack_codes_range(
         const uint8_t* codes,
@@ -62,7 +67,8 @@ void pq4_pack_codes_range(
         size_t i1,
         size_t bbs,
         size_t nsq,
-        uint8_t* blocks);
+        uint8_t* blocks,
+        size_t code_stride = 0);
 
 /** get a single element from a packed codes table
  *
@@ -104,7 +110,7 @@ struct CodePackerPQ4 : CodePacker {
 /** Pack Look-up table for consumption by the kernel.
  *
  * @param nq      number of queries
- * @param nsq     number of sub-quantizers (muliple of 2)
+ * @param nsq     number of sub-quantizers (multiple of 2)
  * @param src     input array, size (nq, 16)
  * @param dest    output array, size (nq, 16)
  */
@@ -115,7 +121,7 @@ void pq4_pack_LUT(int nq, int nsq, const uint8_t* src, uint8_t* dest);
  * @param nq      number of queries
  * @param nb      number of database elements
  * @param bbs     size of database blocks (multiple of 32)
- * @param nsq     number of sub-quantizers (muliple of 2)
+ * @param nsq     number of sub-quantizers (multiple of 2)
  * @param codes   packed codes array
  * @param LUT     packed look-up table
  * @param scaler  scaler to scale the encoded norm
@@ -154,7 +160,7 @@ int pq4_preferred_qbs(int nq);
  *
  * @param qbs     4-bit encoded number of query blocks, the total number of
  *                queries handled (nq) is deduced from it
- * @param nsq     number of sub-quantizers (muliple of 2)
+ * @param nsq     number of sub-quantizers (multiple of 2)
  * @param src     input array, size (nq, 16)
  * @param dest    output array, size (nq, 16)
  * @return nq
@@ -173,11 +179,11 @@ int pq4_pack_LUT_qbs_q_map(
 /** Run accumulation loop.
  *
  * @param qbs     4-bit encoded number of queries
- * @param nb      number of database codes (mutliple of bbs)
+ * @param nb      number of database codes (multiple of bbs)
  * @param nsq     number of sub-quantizers
  * @param codes   encoded database vectors (packed)
  * @param LUT     look-up table (packed)
- * @param res     call-back for the resutls
+ * @param res     call-back for the results
  * @param scaler  scaler to scale the encoded norm
  */
 void pq4_accumulate_loop_qbs(

data/vendor/faiss/faiss/impl/pq4_fast_scan_search_qbs.cpp

@@ -53,8 +53,8 @@ void kernel_accumulate_block(
 
     // _mm_prefetch(codes + 768, 0);
     for (int sq = 0; sq < nsq - scaler.nscale; sq += 2) {
-        // prefetch
-        simd32uint8 c(codes);
+        simd32uint8 c;
+        c.loadu(codes);
         codes += 32;
 
         simd32uint8 mask(0xf);
@@ -79,8 +79,8 @@ void kernel_accumulate_block(
     }
 
     for (int sq = 0; sq < scaler.nscale; sq += 2) {
-        // prefetch
-        simd32uint8 c(codes);
+        simd32uint8 c;
+        c.loadu(codes);
         codes += 32;
 
         simd32uint8 mask(0xf);
@@ -623,7 +623,6 @@ void accumulate(
         ResultHandler& res,
         const Scaler& scaler) {
     assert(nsq % 2 == 0);
-    assert(is_aligned_pointer(codes));
     assert(is_aligned_pointer(LUT));
 
 #define DISPATCH(NQ)                                     \
@@ -782,7 +781,7 @@ void accumulate_to_mem(
 }
 
 int pq4_preferred_qbs(int n) {
-    // from timmings in P141901742, P141902828
+    // from timings in P141901742, P141902828
     static int map[12] = {
             0, 1, 2, 3, 0x13, 0x23, 0x33, 0x223, 0x233, 0x333, 0x2233, 0x2333};
     if (n <= 11) {

data/vendor/faiss/faiss/impl/simd_result_handlers.h

@@ -46,7 +46,7 @@ struct SIMDResultHandler {
     virtual ~SIMDResultHandler() {}
 };
 
-/* Result handler that will return float resutls eventually */
+/* Result handler that will return float results eventually */
 struct SIMDResultHandlerToFloat : SIMDResultHandler {
     size_t nq;     // number of queries
     size_t ntotal; // ignore excess elements after ntotal
@@ -70,13 +70,35 @@ struct SIMDResultHandlerToFloat : SIMDResultHandler {
     virtual void end() {
         normalizers = nullptr;
     }
+
+    // Number of updates made to the underlying data structure.
+    // For example: number of heap updates.
+    virtual size_t num_updates() {
+        return 0;
+    }
+
+    /** Set context information for handlers that need additional data
+     *
+     * This method can be overridden by handlers that need list numbers
+     * and probe mappings (e.g., RaBitQ handlers). Base implementation
+     * does nothing since most handlers don't need this context.
+     *
+     * @param list_no      current inverted list number being processed
+     * @param probe_map    mapping from local query index to probe index
+     */
+    virtual void set_list_context(
+            size_t /* list_no */,
+            const std::vector<int>& /* probe_map */) {
+        // Default implementation does nothing
+        // Derived handlers can override if they need this context
+    }
 };
 
 FAISS_API extern bool simd_result_handlers_accept_virtual;
 
 namespace simd_result_handlers {
 
-/** Dummy structure that just computes a chqecksum on results
+/** Dummy structure that just computes a checksum on results
  * (to avoid the computation to be optimized away) */
 struct DummyResultHandler : SIMDResultHandler {
     size_t cs = 0;
@@ -318,8 +340,8 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
     std::vector<TI> iids;
     float* dis;
     int64_t* ids;
-
-    int64_t k; // number of results to keep
+    size_t k;       // number of results to keep
+    size_t nup = 0; // number of heap updates
 
     HeapHandler(
             size_t nq,
@@ -327,14 +349,30 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
             int64_t k,
             float* dis,
             int64_t* ids,
-            const IDSelector* sel_in)
+            const IDSelector* sel_in,
+            const float* normalizers = nullptr)
             : RHC(nq, ntotal, sel_in),
-              idis(nq * k),
-              iids(nq * k),
+              idis(nq * k, threshold_idis(dis, normalizers)),
+              iids(nq * k, -1),
               dis(dis),
               ids(ids),
-              k(k) {
-        heap_heapify<C>(k * nq, idis.data(), iids.data());
+              k(k) {}
+
+    static uint16_t threshold_idis(float* dis_in, const float* normalizers) {
+        if (dis_in[0] == std::numeric_limits<float>::max()) {
+            return std::numeric_limits<uint16_t>::max();
+        }
+        if (dis_in[0] == std::numeric_limits<float>::lowest()) {
+            return 0;
+        }
+        if (normalizers) {
+            float one_a = 1 / normalizers[0], b = normalizers[1];
+            float f = (dis_in[0] - b) / one_a;
+            f = C::is_max ? std::ceil(f) : std::floor(f);
+            return std::clamp<float>(
+                    f, 0, std::numeric_limits<uint16_t>::max());
+        }
+        return C::neutral();
     }
 
     void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) final {
@@ -372,6 +410,7 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                     if (C::cmp(heap_dis[0], dis_2)) {
                         heap_replace_top<C>(
                                 k, heap_dis, heap_ids, dis_2, real_idx);
+                        nup++;
                     }
                 }
             }
@@ -384,6 +423,7 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 if (C::cmp(heap_dis[0], dis_2)) {
                     int64_t idx = this->adjust_id(b, j);
                     heap_replace_top<C>(k, heap_dis, heap_ids, dis_2, idx);
+                    nup++;
                 }
             }
         }
@@ -408,6 +448,10 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
             }
         }
     }
+
+    size_t num_updates() override {
+        return nup;
+    }
 };
 
 /** Simple top-N implementation using a reservoir.
@@ -726,7 +770,7 @@ void dispatch_SIMDResultHandler_fixedCW(
     } else { // generic handler -- will not be inlined
         FAISS_THROW_IF_NOT_FMT(
                 simd_result_handlers_accept_virtual,
-                "Running vitrual handler for %s",
+                "Running virtual handler for %s",
                 typeid(res).name());
         consumer.template f<SIMDResultHandler>(res, args...);
     }
@@ -757,7 +801,7 @@ void dispatch_SIMDResultHandler(
         } else { // generic path
             FAISS_THROW_IF_NOT_FMT(
                     simd_result_handlers_accept_virtual,
-                    "Running vitrual handler for %s",
+                    "Running virtual handler for %s",
                     typeid(res).name());
             consumer.template f<SIMDResultHandler>(res, args...);
         }

data/vendor/faiss/faiss/impl/zerocopy_io.h

@@ -20,7 +20,7 @@ struct ZeroCopyIOReader : public faiss::IOReader {
     size_t total_ = 0;
 
     ZeroCopyIOReader(const uint8_t* data, size_t size);
-    ~ZeroCopyIOReader();
+    ~ZeroCopyIOReader() override;
 
     void reset();
     size_t get_data_view(void** ptr, size_t size, size_t nitems);