faiss 0.6.3 → 0.6.4

data/vendor/faiss/faiss/impl/binary_hamming/IndexBinaryIVF_impl.h

@@ -39,17 +39,50 @@ namespace faiss {
 
 namespace {
 
+// Whether the computer can measure a whole batch of codes in one call.
 template <class HammingComputer>
-struct IVFBinaryScannerL2 : BinaryInvertedListScanner {
+constexpr bool has_hamming_batch =
+        requires(const uint8_t* tile, const uint8_t* codes, int32_t* dis) {
+            HammingComputer::batch_size;
+            HammingComputer::get_code_size();
+            HammingComputer::build_batch_query(tile, nullptr);
+            HammingComputer::hamming_batch(tile, codes, dis);
+        };
+
+// The query repeated batch_size times, which is what hamming_batch() XORs
+// against. Empty for a computer that does not batch, so those scanners carry
+// neither the buffer nor its alignment.
+template <class HammingComputer>
+struct BatchQueryTile {};
+
+template <class HammingComputer>
+    requires has_hamming_batch<HammingComputer>
+struct BatchQueryTile<HammingComputer> {
+    alignas(64) uint8_t batch_query
+            [HammingComputer::batch_size * HammingComputer::get_code_size()];
+};
+
+template <class HammingComputer>
+struct IVFBinaryScannerL2 : BinaryInvertedListScanner,
+                            BatchQueryTile<HammingComputer> {
     HammingComputer hc;
     size_t code_size;
     bool store_pairs;
 
     IVFBinaryScannerL2(size_t code_size_, bool store_pairs_)
-            : code_size(code_size_), store_pairs(store_pairs_) {}
+            : code_size(code_size_), store_pairs(store_pairs_) {
+        if constexpr (has_hamming_batch<HammingComputer>) {
+            // The batch kernel reads a fixed stride, so a caller that pairs
+            // this computer with another code size would read past the codes.
+            FAISS_THROW_IF_NOT(code_size == HammingComputer::get_code_size());
+        }
+    }
 
     void set_query(const uint8_t* query_vector) override {
         hc.set(query_vector, code_size);
+        if constexpr (has_hamming_batch<HammingComputer>) {
+            HammingComputer::build_batch_query(query_vector, this->batch_query);
+        }
     }
 
     idx_t list_no = 0;
@@ -61,6 +94,31 @@ struct IVFBinaryScannerL2 : BinaryInvertedListScanner {
         return hc.hamming(code);
     }
 
+    // Measures whole batches while at least batch_size codes remain, then
+    // leaves codes and j on the first code the caller must measure singly.
+    // bound is read per lane, so a caller that raises its heap top inside
+    // accept prunes the rest of the batch.
+    template <class Accept>
+    void scan_batch_prefix(
+            size_t n,
+            const uint8_t* __restrict& codes,
+            size_t& j,
+            const uint32_t& bound,
+            Accept&& accept) const {
+        if constexpr (has_hamming_batch<HammingComputer>) {
+            constexpr size_t B = HammingComputer::batch_size;
+            int32_t batch[B];
+            for (; j + B <= n; j += B, codes += B * code_size) {
+                HammingComputer::hamming_batch(this->batch_query, codes, batch);
+                for (size_t t = 0; t < B; t++) {
+                    if (static_cast<uint32_t>(batch[t]) < bound) {
+                        accept(batch[t], j + t);
+                    }
+                }
+            }
+        }
+    }
+
     size_t scan_codes(
             size_t n,
             const uint8_t* __restrict codes,
@@ -70,15 +128,25 @@ struct IVFBinaryScannerL2 : BinaryInvertedListScanner {
             size_t k) const override {
         using C = CMax<int32_t, idx_t>;
 
+        uint32_t bound = static_cast<uint32_t>(simi[0]);
+
         size_t nup = 0;
-        for (size_t j = 0; j < n; j++) {
+        size_t j = 0;
+
+        auto accept = [&](int32_t dis, size_t at) {
+            idx_t id = store_pairs ? lo_build(list_no, at) : ids[at];
+            heap_replace_top<C>(k, simi, idxi, dis, id);
+            bound = static_cast<uint32_t>(simi[0]);
+            nup++;
+        };
+
+        scan_batch_prefix(n, codes, j, bound, accept);
+
+        for (; j < n; j++, codes += code_size) {
             uint32_t dis = hc.hamming(codes);
-            if (dis < static_cast<uint32_t>(simi[0])) {
-                idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
-                heap_replace_top<C>(k, simi, idxi, dis, id);
-                nup++;
+            if (dis < bound) {
+                accept(static_cast<int32_t>(dis), j);
             }
-            codes += code_size;
         }
         return nup;
     }
@@ -89,13 +157,21 @@ struct IVFBinaryScannerL2 : BinaryInvertedListScanner {
             const idx_t* __restrict ids,
             int radius,
             RangeQueryResult& result) const override {
-        for (size_t j = 0; j < n; j++) {
+        const uint32_t bound = static_cast<uint32_t>(radius);
+        size_t j = 0;
+
+        auto accept = [&](int32_t dis, size_t at) {
+            int64_t id = store_pairs ? lo_build(list_no, at) : ids[at];
+            result.add(static_cast<uint32_t>(dis), id);
+        };
+
+        scan_batch_prefix(n, codes, j, bound, accept);
+
+        for (; j < n; j++, codes += code_size) {
             uint32_t dis = hc.hamming(codes);
-            if (dis < static_cast<uint32_t>(radius)) {
-                int64_t id = store_pairs ? lo_build(list_no, j) : ids[j];
-                result.add(dis, id);
+            if (dis < bound) {
+                accept(static_cast<int32_t>(dis), j);
             }
-            codes += code_size;
         }
     }
 };

data/vendor/faiss/faiss/impl/expanded_scanners.h

@@ -35,12 +35,16 @@ size_t run_scan_codes1(
     size_t list_no = scanner.list_no;
     size_t code_size = scanner.code_size;
     const IDSelector* sel = scanner.sel;
+    // If the selector implements IDSelectorWithContext, hand it the scan
+    // context (ids, list_size, j) so it can exploit scan-order locality; the
+    // dispatch caches the once-per-list RTTI detection.
+    const IDSelectorContextDispatch sel_dispatch(sel, store_pairs);
     float threshold = handler.threshold;
     for (size_t j = 0; j < list_size; j++) {
         if (use_sel) {
             int64_t id = store_pairs ? lo_build(list_no, j) : ids[j];
             // skip code without computing distance
-            if (!sel->is_member(id)) {
+            if (!sel_dispatch.is_member(id, IDScanContext{ids, list_size, j})) {
                 codes += code_size;
                 continue;
             }

data/vendor/faiss/faiss/impl/fast_scan/decompose_qbs.h

@@ -40,6 +40,7 @@ void kernel_accumulate_block(
 #ifdef __AVX512F__
     if constexpr (
             KernelSL == SIMDLevel::AVX512 ||
+            KernelSL == SIMDLevel::AVX512_VPOPCNT ||
             KernelSL == SIMDLevel::AVX512_SPR) {
         pq4_kernel_qbs_512<NQ>(nsq, codes, LUT, res, scaler);
     } else {

data/vendor/faiss/faiss/impl/index_read.cpp

@@ -545,7 +545,7 @@ std::unique_ptr<InvertedLists> read_InvertedLists_up(
         READ1(n_levels);
         FAISS_THROW_IF_NOT_FMT(
                 n_levels > 0, "invalid ilpn n_levels %zd", n_levels);
-        constexpr size_t bs = Panorama::kDefaultBatchSize;
+        constexpr size_t bs = Panorama::kLegacyBatchSize;
         auto ailp = std::make_unique<ArrayInvertedListsPanorama>(
                 nlist, code_size, n_levels, bs);
         std::vector<size_t> sizes(nlist);
@@ -821,6 +821,10 @@ static void read_AdditiveQuantizer(AdditiveQuantizer& aq, IOReader* f) {
     }
 
     aq.set_derived_values();
+    FAISS_THROW_IF_NOT_FMT(
+            aq.code_size > 0,
+            "invalid AdditiveQuantizer: nbits sum to 0 bits, code_size %zd",
+            aq.code_size);
 
     // Sanity-check codebooks size without knowing the effective dimension.
     // codebooks stores effective_d * total_codebook_size floats, so its
@@ -1160,8 +1164,7 @@ void read_ScalarQuantizer(
         }
     }
 
-    // TurboQ full types: extract seed and qjl_type from trained,
-    // regenerate projection matrix.
+    // TurboQ full types: extract seed and qjl_type from trained.
     if (ScalarQuantizer::TurboQuantRefine::is_turboq_full(ivsc->qtype) &&
         ivsc->trained.size() >= 3) {
         size_t n = ivsc->trained.size();
@@ -1170,7 +1173,6 @@ void read_ScalarQuantizer(
         ivsc->turboq_refine.seed =
                 ScalarQuantizer::TurboQuantRefine::unpack_seed(
                         ivsc->trained[n - 3], ivsc->trained[n - 2]);
-        ivsc->turboq_refine.init_projection(ivsc->d);
     }
 }
 
@@ -1688,6 +1690,10 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         int d;
         size_t n_levels, batch_size;
         READ1(d);
+        // This branch does not go through read_index_header, so the range
+        // check that guards `d` for every other index type has to be
+        // repeated here.
+        FAISS_CHECK_RANGE(d, 0, (1 << 20) + 1);
         READ1(n_levels);
         FAISS_THROW_IF_NOT_FMT(n_levels > 0, "invalid n_levels %zd", n_levels);
         READ1(batch_size);
@@ -1702,24 +1708,36 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
                     d, n_levels, batch_size);
         }
         READ1(idxp->ntotal);
+        FAISS_THROW_IF_NOT_FMT(
+                idxp->ntotal >= 0,
+                "invalid ntotal %" PRId64 " read from IxFP index",
+                (int64_t)idxp->ntotal);
         READ1_BOOL(idxp->is_trained);
         READVECTOR(idxp->codes);
         READVECTOR(idxp->cum_sums);
-        size_t num_slots = mul_no_overflow(
-                ((size_t)idxp->ntotal + idxp->batch_size - 1) /
-                        idxp->batch_size,
-                idxp->batch_size,
+        const size_t ntotal = (size_t)idxp->ntotal;
+        const size_t num_batches =
+                ntotal / batch_size + (ntotal % batch_size != 0);
+        const size_t num_slots = mul_no_overflow(
+                num_batches,
+                batch_size,
                 "IndexFlatPanorama num_batches*batch_size");
-        FAISS_THROW_IF_NOT(
-                idxp->codes.size() ==
-                mul_no_overflow(
-                        num_slots, idxp->code_size, "IndexFlatPanorama codes"));
-        FAISS_THROW_IF_NOT(
-                idxp->cum_sums.size() ==
-                mul_no_overflow(
-                        num_slots,
-                        idxp->pano.n_levels + 1,
-                        "IndexFlatPanorama cum_sums"));
+        const size_t expected_codes_size = mul_no_overflow(
+                num_slots, idxp->code_size, "IndexFlatPanorama codes");
+        FAISS_THROW_IF_NOT_FMT(
+                idxp->codes.size() == expected_codes_size,
+                "IndexFlatPanorama codes size mismatch: got %zu, expected %zu",
+                idxp->codes.size(),
+                expected_codes_size);
+        const size_t expected_cum_sums_size = mul_no_overflow(
+                num_slots,
+                idxp->pano.n_levels + 1,
+                "IndexFlatPanorama cum_sums");
+        FAISS_THROW_IF_NOT_FMT(
+                idxp->cum_sums.size() == expected_cum_sums_size,
+                "IndexFlatPanorama cum_sums size mismatch: got %zu, expected %zu",
+                idxp->cum_sums.size(),
+                expected_cum_sums_size);
         idxp->verbose = false;
         idx = std::move(idxp);
     } else if (
@@ -2136,7 +2154,7 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         read_ivf_header(ivfp.get(), f);
         ivfp->code_size = ivfp->d * sizeof(float);
         READ1(ivfp->n_levels);
-        ivfp->batch_size = Panorama::kDefaultBatchSize;
+        ivfp->batch_size = Panorama::kLegacyBatchSize;
         read_InvertedLists(*ivfp, f, io_flags);
         idx = std::move(ivfp);
     } else if (h == fourcc("IwP2")) {
@@ -2163,6 +2181,12 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         read_ScalarQuantizer(&idxs->sq, f, *idxs);
         read_vector(idxs->codes, f);
         idxs->code_size = idxs->sq.code_size;
+        FAISS_THROW_IF_NOT(
+                idxs->codes.size() ==
+                mul_no_overflow(
+                        (size_t)idxs->ntotal,
+                        idxs->code_size,
+                        "IndexScalarQuantizer codes"));
         idx = std::move(idxs);
     } else if (h == fourcc("IxLa")) {
         int d, nsq, scale_nbit, r2;
@@ -2374,8 +2398,18 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         // Validate transform chain dimension consistency:
         // chain[0].d_in must equal the outer index d, consecutive
         // transforms must have matching d_out/d_in, and the last
-        // transform's d_out must equal the sub-index d.
-        if (nt > 0) {
+        // transform's d_out must equal the sub-index d. With an empty
+        // chain the sub-index d must equal the outer d directly, because
+        // reconstruct() then hands the caller's buffer -- sized from the
+        // outer d -- straight to the sub-index.
+        if (nt == 0 && ixpt->index) {
+            FAISS_THROW_IF_NOT_FMT(
+                    ixpt->index->d == ixpt->d,
+                    "IndexPreTransform empty chain: sub-index d=%d "
+                    "!= index d=%d",
+                    ixpt->index->d,
+                    ixpt->d);
+        } else if (nt > 0) {
             FAISS_THROW_IF_NOT_FMT(
                     ixpt->chain[0]->d_in == ixpt->d,
                     "IndexPreTransform chain[0] d_in=%d != index d=%d",
@@ -2497,7 +2531,7 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
     } else if (
             h == fourcc("IHNf") || h == fourcc("IHNp") || h == fourcc("IHNs") ||
             h == fourcc("IHN2") || h == fourcc("IHNc") || h == fourcc("IHc2") ||
-            h == fourcc("IHfP") || h == fourcc("IH00")) {
+            h == fourcc("IHfP") || h == fourcc("IHNr") || h == fourcc("IH00")) {
         std::unique_ptr<IndexHNSW> idxhnsw;
         if (h == fourcc("IH00")) {
             idxhnsw = std::make_unique<IndexHNSW>();
@@ -2515,6 +2549,8 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
             idxhnsw = std::make_unique<IndexHNSWCagra>();
         } else if (h == fourcc("IHc2")) {
             idxhnsw = std::make_unique<IndexHNSWCagra>();
+        } else if (h == fourcc("IHNr")) {
+            idxhnsw = std::make_unique<IndexHNSWRaBitQ>();
         }
         read_index_header(*idxhnsw, f);
         if (h == fourcc("IHfP")) {
@@ -2525,10 +2561,21 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
                     "dynamic_cast to IndexHNSWFlatPanorama failed");
             size_t nlevels;
             READ1(nlevels);
+            FAISS_THROW_IF_NOT_FMT(
+                    nlevels > 0, "invalid IHfP n_levels %zd", nlevels);
             const_cast<size_t&>(idx_panorama->num_panorama_levels) = nlevels;
             const_cast<Panorama&>(idx_panorama->pano) =
                     Panorama(idx_panorama->d * sizeof(float), nlevels, 1);
             READVECTOR(idx_panorama->cum_sums);
+            // Both the search path and get_cum_sum() index cum_sums at
+            // stride pano.n_levels + 1, which may be lower than the
+            // serialized nlevels if set_derived_values() truncated it.
+            FAISS_THROW_IF_NOT(
+                    idx_panorama->cum_sums.size() ==
+                    mul_no_overflow(
+                            (size_t)idx_panorama->ntotal,
+                            idx_panorama->pano.n_levels + 1,
+                            "IndexHNSWFlatPanorama cum_sums"));
         } else if (h == fourcc("IHNc") || h == fourcc("IHc2")) {
             READ1_BOOL(idxhnsw->keep_max_size_level0);
             auto idx_hnsw_cagra = dynamic_cast<IndexHNSWCagra*>(idxhnsw.get());
@@ -2549,7 +2596,8 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
                 "HNSW levels size %zu != index ntotal %" PRId64,
                 idxhnsw->hnsw.levels.size(),
                 idxhnsw->ntotal);
-        idxhnsw->hnsw.is_panorama = (h == fourcc("IHfP"));
+        idxhnsw->hnsw.search_method =
+                h == fourcc("IHfP") ? HNSW::SM_PANORAMA : HNSW::SM_DEFAULT;
         // `HNSW::is_similarity` is intentionally not serialized, so we
         // re-derive it here from the persisted metric type. Without this,
         // a saved IP/similarity index would come back configured as a
@@ -2571,6 +2619,57 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
                     idxhnsw->storage->d,
                     idxhnsw->d);
         }
+        if (h == fourcc("IHNr")) {
+            auto* idx_rabitq = dynamic_cast<IndexHNSWRaBitQ*>(idxhnsw.get());
+            FAISS_THROW_IF_NOT_MSG(
+                    idx_rabitq, "IHNr must deserialize to an IndexHNSWRaBitQ");
+            FAISS_THROW_IF_NOT_MSG(
+                    idxhnsw->metric_type == METRIC_L2,
+                    "IndexHNSWRaBitQ supports only the L2 metric");
+            bool staged;
+            READ1_BOOL(staged);
+            idxhnsw->hnsw.search_method =
+                    staged ? HNSW::SM_RABITQ : HNSW::SM_DEFAULT;
+            if (idxhnsw->storage) {
+                auto* rq = dynamic_cast<IndexRaBitQ*>(idxhnsw->storage);
+                FAISS_THROW_IF_NOT_MSG(
+                        rq, "IndexHNSWRaBitQ storage must be an IndexRaBitQ");
+                FAISS_THROW_IF_NOT_MSG(
+                        rq->metric_type == idxhnsw->metric_type &&
+                                rq->rabitq.metric_type == idxhnsw->metric_type,
+                        "IndexHNSWRaBitQ storage metric mismatch");
+                FAISS_THROW_IF_NOT_MSG(
+                        rq->is_trained == idxhnsw->is_trained,
+                        "IndexHNSWRaBitQ storage training state mismatch");
+                FAISS_THROW_IF_NOT_FMT(
+                        rq->rabitq.nb_bits >= 1 && rq->rabitq.nb_bits <= 9,
+                        "invalid RaBitQ nb_bits=%zu",
+                        rq->rabitq.nb_bits);
+                const size_t expected_code_size =
+                        rq->rabitq.compute_code_size(rq->d, rq->rabitq.nb_bits);
+                validate_code_size_match(
+                        rq->rabitq.code_size,
+                        expected_code_size,
+                        "IndexHNSWRaBitQ quantizer");
+                validate_code_size_match(
+                        rq->code_size,
+                        expected_code_size,
+                        "IndexHNSWRaBitQ storage");
+                FAISS_THROW_IF_NOT(
+                        rq->codes.size() ==
+                        mul_no_overflow(
+                                static_cast<size_t>(rq->ntotal),
+                                rq->code_size,
+                                "IndexHNSWRaBitQ codes"));
+                FAISS_THROW_IF_NOT_MSG(
+                        !rq->is_trained ||
+                                rq->center.size() == static_cast<size_t>(rq->d),
+                        "IndexHNSWRaBitQ center size mismatch");
+                FAISS_THROW_IF_NOT_MSG(
+                        staged == (rq->rabitq.nb_bits >= 2),
+                        "IndexHNSWRaBitQ staged-search metadata mismatch");
+            }
+        }
         if (h == fourcc("IHN2")) {
             FAISS_THROW_IF_NOT_MSG(
                     idxhnsw->storage,
@@ -2838,7 +2937,7 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         auto idxq = std::make_unique<IndexRaBitQ>();
         read_index_header(*idxq, f);
         read_RaBitQuantizer(idxq->rabitq, f, idxq->d, false);
-        READVECTOR(idxq->codes);
+        read_vector(idxq->codes, f);
         READVECTOR(idxq->center);
         READ1(idxq->qb);
         // qb=0: Not quantized - direct distance computation on given float32s.
@@ -2857,7 +2956,7 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         read_index_header(*idxq, f);
         read_RaBitQuantizer(
                 idxq->rabitq, f, idxq->d, true); // Reads nb_bits from file
-        READVECTOR(idxq->codes);
+        read_vector(idxq->codes, f);
         READVECTOR(idxq->center);
         READ1(idxq->qb);
         // qb=0: Not quantized - direct distance computation on given float32s.
@@ -3052,7 +3151,8 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
         bool initialized;
         READ1_BOOL(initialized);
         if (initialized) {
-            faiss::svs_io::ReaderStreambuf rbuf(f);
+            faiss::svs_io::ReaderStreambuf rbuf(
+                    f, get_deserialization_vector_byte_limit());
             std::istream is(&rbuf);
             svs_ivf->deserialize_impl(is);
         }
@@ -3060,7 +3160,8 @@ std::unique_ptr<Index> read_index_up(IOReader* f, int io_flags) {
             bool trained;
             READ1_BOOL(trained);
             if (trained) {
-                faiss::svs_io::ReaderStreambuf rbuf(f);
+                faiss::svs_io::ReaderStreambuf rbuf(
+                        f, get_deserialization_vector_byte_limit());
                 std::istream is(&rbuf);
                 auto* leanvec =
                         dynamic_cast<IndexSVSIVFLeanVec*>(svs_ivf.get());
@@ -3390,7 +3491,7 @@ std::unique_ptr<IndexBinary> read_index_binary_up(IOReader* f, int io_flags) {
         auto idxhnsw = std::make_unique<IndexBinaryHNSW>();
         read_index_binary_header(*idxhnsw, f);
         read_HNSW(idxhnsw->hnsw, f);
-        idxhnsw->hnsw.is_panorama = false;
+        idxhnsw->hnsw.search_method = HNSW::SM_DEFAULT;
         FAISS_THROW_IF_NOT_FMT(
                 idxhnsw->hnsw.levels.size() == (size_t)idxhnsw->ntotal,
                 "IndexBinaryHNSW HNSW levels size %zu != ntotal %" PRId64,
@@ -3414,7 +3515,7 @@ std::unique_ptr<IndexBinary> read_index_binary_up(IOReader* f, int io_flags) {
         READ1_BOOL(idxhnsw->base_level_only);
         READ1(idxhnsw->num_base_level_search_entrypoints);
         read_HNSW(idxhnsw->hnsw, f);
-        idxhnsw->hnsw.is_panorama = false;
+        idxhnsw->hnsw.search_method = HNSW::SM_DEFAULT;
         FAISS_THROW_IF_NOT_FMT(
                 idxhnsw->hnsw.levels.size() == (size_t)idxhnsw->ntotal,
                 "IndexBinaryHNSWCagra HNSW levels size %zu != ntotal %" PRId64,

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

@@ -275,20 +275,12 @@ void write_InvertedLists(const InvertedLists* ils, IOWriter* f) {
     } else if (
             const auto& ailp =
                     dynamic_cast<const ArrayInvertedListsPanorama*>(ils)) {
-        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 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;
@@ -736,18 +728,11 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
     } else if (
             const IndexIVFFlatPanorama* ivfp =
                     dynamic_cast<const IndexIVFFlatPanorama*>(idx)) {
-        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);
-        }
+        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 =
@@ -888,12 +873,22 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
                 : dynamic_cast<const IndexHNSWSQ*>(idx)     ? fourcc("IHNs")
                 : dynamic_cast<const IndexHNSW2Level*>(idx) ? fourcc("IHN2")
                 : dynamic_cast<const IndexHNSWCagra*>(idx)  ? fourcc("IHc2")
+                : dynamic_cast<const IndexHNSWRaBitQ*>(idx) ? fourcc("IHNr")
                 : typeid(*idx) == typeid(IndexHNSW)         ? fourcc("IH00")
                                                             : 0;
         FAISS_THROW_IF_NOT_FMT(
                 h != 0,
                 "don't know how to serialize this IndexHNSW subtype: %s",
                 typeid(*idx).name());
+        const IndexRaBitQ* storage_rabitq = nullptr;
+        if (h == fourcc("IHNr")) {
+            storage_rabitq = dynamic_cast<const IndexRaBitQ*>(idxhnsw->storage);
+            FAISS_THROW_IF_NOT_MSG(
+                    storage_rabitq ||
+                            ((io_flags & IO_FLAG_SKIP_STORAGE) &&
+                             idxhnsw->storage == nullptr),
+                    "IndexHNSWRaBitQ requires IndexRaBitQ storage");
+        }
         WRITE1(h);
         write_index_header(idxhnsw, f);
         if (h == fourcc("IHfP")) {
@@ -916,6 +911,16 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) {
         } else {
             write_index(idxhnsw->storage, f);
         }
+        if (h == fourcc("IHNr")) {
+            // The staged flag is graph-traversal state, so it has to live here:
+            // with IO_FLAG_SKIP_STORAGE there is no storage to derive it from.
+            // Storage-owned settings are not duplicated in this payload;
+            // IndexRaBitQ serializes whatever it owns.
+            const bool staged = storage_rabitq
+                    ? storage_rabitq->rabitq.nb_bits >= 2
+                    : idxhnsw->hnsw.search_method == HNSW::SM_RABITQ;
+            WRITE1(staged);
+        }
     } else if (const IndexNSG* idxnsg = dynamic_cast<const IndexNSG*>(idx)) {
         uint32_t h = dynamic_cast<const IndexNSGFlat*>(idx) ? fourcc("INSf")
                 : dynamic_cast<const IndexNSGPQ*>(idx)      ? fourcc("INSp")