faiss 0.5.3 → 0.6.0

data/vendor/faiss/faiss/IndexLattice.cpp

@@ -9,6 +9,7 @@
 
 #include <faiss/IndexLattice.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/simd_dispatch.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/hamming.h> // for the bitstring routines
 
@@ -44,17 +45,19 @@ void IndexLattice::train(idx_t n, const float* x) {
         maxs[sq] = -1;
     }
 
-    for (idx_t i = 0; i < n; i++) {
-        for (int sq = 0; sq < nsq; sq++) {
-            float norm2 = fvec_norm_L2sqr(x + i * d + sq * dsq, dsq);
-            if (norm2 > maxs[sq]) {
-                maxs[sq] = norm2;
-            }
-            if (norm2 < mins[sq]) {
-                mins[sq] = norm2;
+    with_simd_level([&]<SIMDLevel SL>() {
+        for (idx_t i = 0; i < n; i++) {
+            for (int sq = 0; sq < nsq; sq++) {
+                float norm2 = fvec_norm_L2sqr<SL>(x + i * d + sq * dsq, dsq);
+                if (norm2 > maxs[sq]) {
+                    maxs[sq] = norm2;
+                }
+                if (norm2 < mins[sq]) {
+                    mins[sq] = norm2;
+                }
             }
         }
-    }
+    });
 
     for (int sq = 0; sq < nsq; sq++) {
         mins[sq] = sqrtf(mins[sq]);
@@ -74,24 +77,26 @@ void IndexLattice::sa_encode(idx_t n, const float* x, uint8_t* codes) const {
     const float* maxs = mins + nsq;
     int64_t sc = int64_t(1) << scale_nbit;
 
+    with_simd_level([&]<SIMDLevel SL>() {
 #pragma omp parallel for
-    for (idx_t i = 0; i < n; i++) {
-        BitstringWriter wr(codes + i * code_size, code_size);
-        const float* xi = x + i * d;
-        for (int j = 0; j < nsq; j++) {
-            float nj = (sqrtf(fvec_norm_L2sqr(xi, dsq)) - mins[j]) * sc /
-                    (maxs[j] - mins[j]);
-            if (nj < 0) {
-                nj = 0;
-            }
-            if (nj >= sc) {
-                nj = sc - 1;
+        for (idx_t i = 0; i < n; i++) {
+            BitstringWriter wr(codes + i * code_size, code_size);
+            const float* xi = x + i * d;
+            for (int j = 0; j < nsq; j++) {
+                float nj = (sqrtf(fvec_norm_L2sqr<SL>(xi, dsq)) - mins[j]) *
+                        sc / (maxs[j] - mins[j]);
+                if (nj < 0) {
+                    nj = 0;
+                }
+                if (nj >= sc) {
+                    nj = sc - 1;
+                }
+                wr.write((int64_t)nj, scale_nbit);
+                wr.write(zn_sphere_codec.encode(xi), lattice_nbit);
+                xi += dsq;
             }
-            wr.write((int64_t)nj, scale_nbit);
-            wr.write(zn_sphere_codec.encode(xi), lattice_nbit);
-            xi += dsq;
         }
-    }
+    });
 }
 
 void IndexLattice::sa_decode(idx_t n, const uint8_t* codes, float* x) const {

data/vendor/faiss/faiss/IndexNNDescent.cpp

@@ -19,6 +19,7 @@
 #include <faiss/IndexFlat.h>
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/VisitedTable.h>
 #include <faiss/utils/distances.h>
 
 extern "C" {

data/vendor/faiss/faiss/IndexNSG.cpp

@@ -16,6 +16,7 @@
 #include <faiss/IndexNNDescent.h>
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/VisitedTable.h>
 #include <faiss/utils/distances.h>
 
 namespace faiss {
@@ -74,7 +75,7 @@ void IndexNSG::search(
 
 #pragma omp parallel
         {
-            VisitedTable vt(ntotal);
+            VisitedTable vt(ntotal, nsg.use_visited_hashset);
 
             std::unique_ptr<DistanceComputer> dis(
                     storage_distance_computer(storage));

data/vendor/faiss/faiss/IndexNSG.h

@@ -9,8 +9,6 @@
 
 #pragma once
 
-#include <vector>
-
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexNNDescent.h>
 #include <faiss/IndexPQ.h>

data/vendor/faiss/faiss/IndexNeuralNetCodec.cpp

@@ -24,7 +24,7 @@ IndexNeuralNetCodec::IndexNeuralNetCodec(
     is_trained = false;
 }
 
-void IndexNeuralNetCodec::train(idx_t n, const float* x) {
+void IndexNeuralNetCodec::train(idx_t /*n*/, const float* /*x*/) {
     FAISS_THROW_MSG("Training not implemented in C++, use Pytorch");
 }
 

data/vendor/faiss/faiss/IndexPQ.cpp

@@ -19,7 +19,8 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/hamming.h>
 
-#include <faiss/impl/code_distance/code_distance.h>
+#include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
+#include <faiss/impl/simd_dispatch.h>
 
 namespace faiss {
 
@@ -72,8 +73,9 @@ void IndexPQ::train(idx_t n, const float* x) {
 
 namespace {
 
-template <class PQDecoder>
+template <class PQCodeDist>
 struct PQDistanceComputer : FlatCodesDistanceComputer {
+    using PQDecoder = typename PQCodeDist::PQDecoder;
     size_t d;
     MetricType metric;
     idx_t nb;
@@ -86,7 +88,7 @@ struct PQDistanceComputer : FlatCodesDistanceComputer {
     float distance_to_code(const uint8_t* code) final {
         ndis++;
 
-        float dis = distance_single_code<PQDecoder>(
+        float dis = PQCodeDist::distance_single_code(
                 pq.M, pq.nbits, precomputed_table.data(), code);
         return dis;
     }
@@ -134,16 +136,23 @@ struct PQDistanceComputer : FlatCodesDistanceComputer {
     }
 };
 
+template <SIMDLevel SL>
+FlatCodesDistanceComputer* get_FlatCodesDistanceComputer1(
+        const IndexPQ& index) {
+    if (index.pq.nbits == 8) {
+        return new PQDistanceComputer<PQCodeDistance<PQDecoder8, SL>>(index);
+    } else if (index.pq.nbits == 16) {
+        return new PQDistanceComputer<PQCodeDistance<PQDecoder16, SL>>(index);
+    } else {
+        return new PQDistanceComputer<PQCodeDistance<PQDecoderGeneric, SL>>(
+                index);
+    }
+}
+
 } // namespace
 
 FlatCodesDistanceComputer* IndexPQ::get_FlatCodesDistanceComputer() const {
-    if (pq.nbits == 8) {
-        return new PQDistanceComputer<PQDecoder8>(*this);
-    } else if (pq.nbits == 16) {
-        return new PQDistanceComputer<PQDecoder16>(*this);
-    } else {
-        return new PQDistanceComputer<PQDecoderGeneric>(*this);
-    }
+    DISPATCH_SIMDLevel(get_FlatCodesDistanceComputer1, *this);
 }
 
 /*****************************************

data/vendor/faiss/faiss/IndexRaBitQ.cpp

@@ -8,6 +8,7 @@
 #include <faiss/IndexRaBitQ.h>
 
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/RaBitQUtils.h>
 #include <faiss/impl/ResultHandler.h>
 #include <memory>
 
@@ -16,6 +17,8 @@ namespace faiss {
 // Forward declaration from RaBitQuantizer.cpp
 struct RaBitQDistanceComputer;
 
+using rabitq_utils::SignBitFactorsWithError;
+
 IndexRaBitQ::IndexRaBitQ() = default;
 
 IndexRaBitQ::IndexRaBitQ(idx_t d, MetricType metric, uint8_t nb_bits_in)
@@ -141,19 +144,29 @@ struct Run_search_with_dc_res {
 
                             local_1bit_evaluations++;
 
-                            // Stage 1: Compute 1-bit lower bound
-                            float lower_bound = dc->lower_bound_distance(code);
-
-                            // Stage 2: Adaptive filtering using threshold
-                            // For L2 (min-heap): filter if lower_bound <
-                            // resi.threshold For IP (max-heap): filter if
-                            // lower_bound > resi.threshold Note: Using
-                            // resi.threshold directly (not cached) enables more
-                            // aggressive filtering as the heap is updated
-                            bool should_refine = is_similarity
-                                    ? (lower_bound > resi.threshold)
-                                    : (lower_bound < resi.threshold);
-
+                            // Stage 1: Compute distance bound using 1-bit codes
+                            // For L2 (min-heap): use lower_bound (est -
+                            // error) For IP (max-heap): use upper_bound (est
+                            // + error)
+                            float est_distance =
+                                    dc->distance_to_code_1bit(code);
+
+                            // Extract f_error for filtering
+                            size_t code_size_base = (index->d + 7) / 8;
+                            const rabitq_utils::SignBitFactorsWithError*
+                                    base_fac = reinterpret_cast<
+                                            const rabitq_utils::
+                                                    SignBitFactorsWithError*>(
+                                            code + code_size_base);
+
+                            // Stage 2: Adaptive filtering
+                            bool should_refine =
+                                    rabitq_utils::should_refine_candidate(
+                                            est_distance,
+                                            base_fac->f_error,
+                                            dc->g_error,
+                                            resi.threshold,
+                                            is_similarity);
                             if (should_refine) {
                                 local_multibit_evaluations++;
                                 // Compute full multi-bit distance

data/vendor/faiss/faiss/IndexRaBitQ.h

@@ -14,7 +14,7 @@
 namespace faiss {
 
 struct RaBitQSearchParameters : SearchParameters {
-    uint8_t qb = 0;
+    uint8_t qb = 4;
     bool centered = false;
 };
 
@@ -26,7 +26,7 @@ struct IndexRaBitQ : IndexFlatCodes {
 
     // the default number of bits to quantize a query with.
     // use '0' to disable quantization and use raw fp32 values.
-    uint8_t qb = 0;
+    uint8_t qb = 4;
 
     // quantize the query with a zero-centered scalar quantizer.
     bool centered = false;

data/vendor/faiss/faiss/IndexRaBitQFastScan.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <faiss/IndexRaBitQFastScan.h>
+#include <faiss/impl/CodePackerRaBitQ.h>
 #include <faiss/impl/FastScanDistancePostProcessing.h>
 #include <faiss/impl/RaBitQUtils.h>
 #include <faiss/impl/RaBitQuantizerMultiBit.h>
@@ -21,17 +22,7 @@ static inline size_t roundup(size_t a, size_t b) {
 }
 
 size_t IndexRaBitQFastScan::compute_per_vector_storage_size() const {
-    const size_t ex_bits = rabitq.nb_bits - 1;
-
-    if (ex_bits == 0) {
-        // 1-bit: only SignBitFactors
-        return sizeof(rabitq_utils::SignBitFactors);
-    } else {
-        // Multi-bit: SignBitFactorsWithError + ExtraBitsFactors +
-        // mag-codes
-        return sizeof(SignBitFactorsWithError) + sizeof(ExtraBitsFactors) +
-                (d * ex_bits + 7) / 8;
-    }
+    return rabitq_utils::compute_per_vector_storage_size(rabitq.nb_bits, d);
 }
 
 IndexRaBitQFastScan::IndexRaBitQFastScan() = default;
@@ -64,9 +55,51 @@ IndexRaBitQFastScan::IndexRaBitQFastScan(
     // Set RaBitQ-specific parameters
     qb = 8;
     center.resize(d, 0.0f);
+}
 
-    // Initialize empty flat storage
-    flat_storage.clear();
+CodePacker* IndexRaBitQFastScan::get_CodePacker() const {
+    return new CodePackerRaBitQ(M2, bbs, compute_per_vector_storage_size());
+}
+
+size_t IndexRaBitQFastScan::remove_ids(const IDSelector& sel) {
+    const size_t block_stride = get_block_stride();
+
+    idx_t j = 0;
+    std::vector<uint8_t> buffer(code_size);
+    std::unique_ptr<CodePacker> packer(get_CodePacker());
+    for (idx_t i = 0; i < ntotal; i++) {
+        if (sel.is_member(i)) {
+        } else {
+            if (i > j) {
+                packer->unpack_1(codes.data(), i, buffer.data());
+                packer->pack_1(buffer.data(), j, codes.data());
+            }
+            j++;
+        }
+    }
+    size_t nremove = ntotal - j;
+    if (nremove > 0) {
+        ntotal = j;
+        ntotal2 = roundup(ntotal, bbs);
+        size_t new_size = ntotal2 / bbs * block_stride;
+
+        // Zero out stale data in the last block beyond the retained vectors.
+        // This is necessary because pq4_pack_codes_range uses |= to write
+        // new codes, so any stale non-zero nibbles would corrupt future adds.
+        // pack_1 with a zero buffer zeroes both PQ4 codes and aux data.
+        const size_t last_pos = ntotal % bbs;
+        if (last_pos > 0) {
+            const size_t last_block = ntotal / bbs;
+            std::vector<uint8_t> zero_code(code_size, 0);
+            for (size_t pos = last_pos; pos < bbs; pos++) {
+                packer->pack_1(
+                        zero_code.data(), last_block * bbs + pos, codes.data());
+            }
+        }
+
+        codes.resize(new_size);
+    }
+    return nremove;
 }
 
 IndexRaBitQFastScan::IndexRaBitQFastScan(const IndexRaBitQ& orig, int bbs)
@@ -104,58 +137,59 @@ IndexRaBitQFastScan::IndexRaBitQFastScan(const IndexRaBitQ& orig, int bbs)
 
     // If the original index has data, extract factors and pack codes
     if (ntotal > 0) {
-        // Compute per-vector storage size for flat storage
         const size_t storage_size = compute_per_vector_storage_size();
-
-        // Allocate flat storage
-        flat_storage.resize(ntotal * storage_size);
-
-        // Copy factors directly from original codes
         const size_t bit_pattern_size = (d + 7) / 8;
-        for (idx_t i = 0; i < ntotal; i++) {
-            const uint8_t* orig_code = orig.codes.data() + i * orig.code_size;
-            const uint8_t* source_factors_ptr = orig_code + bit_pattern_size;
-            uint8_t* storage = flat_storage.data() + i * storage_size;
-            memcpy(storage, source_factors_ptr, storage_size);
-        }
 
         // Convert RaBitQ bit format to FastScan 4-bit sub-quantizer format
-        // This follows the same pattern as IndexPQFastScan constructor
         AlignedTable<uint8_t> fastscan_codes(ntotal * code_size);
         memset(fastscan_codes.get(), 0, ntotal * code_size);
 
-        // Convert from RaBitQ 1-bit-per-dimension to FastScan
-        // 4-bit-per-sub-quantizer
         for (idx_t i = 0; i < ntotal; i++) {
             const uint8_t* orig_code = orig.codes.data() + i * orig.code_size;
             uint8_t* fs_code = fastscan_codes.get() + i * code_size;
 
-            // Convert each dimension's bit (same logic as compute_codes)
             for (size_t j = 0; j < orig.d; j++) {
-                // Extract bit from original RaBitQ format
                 const size_t orig_byte_idx = j / 8;
                 const size_t orig_bit_offset = j % 8;
                 const bool bit_value =
                         (orig_code[orig_byte_idx] >> orig_bit_offset) & 1;
 
-                // Use RaBitQUtils for consistent bit setting
                 if (bit_value) {
                     rabitq_utils::set_bit_fastscan(fs_code, j);
                 }
             }
         }
 
-        // Pack the converted codes using pq4_pack_codes with custom stride
-        codes.resize(ntotal2 * M2 / 2);
-        pq4_pack_codes(
+        // Pack the converted codes using enlarged block layout
+        const size_t block_stride = get_block_stride();
+        const size_t n_blocks = ntotal2 / bbs;
+        codes.resize(n_blocks * block_stride);
+        memset(codes.get(), 0, n_blocks * block_stride);
+        pq4_pack_codes_range(
                 fastscan_codes.get(),
-                ntotal,
                 M,
-                ntotal2,
+                0,
+                ntotal,
                 bbs,
                 M2,
                 codes.get(),
-                code_size);
+                code_size,
+                block_stride);
+
+        // Copy auxiliary data from original codes into block aux region
+        const size_t packed_block_size = ((M2 + 1) / 2) * bbs;
+        for (idx_t i = 0; i < ntotal; i++) {
+            const uint8_t* src =
+                    orig.codes.data() + i * orig.code_size + bit_pattern_size;
+            uint8_t* dst = rabitq_utils::get_block_aux_ptr(
+                    codes.get(),
+                    i,
+                    bbs,
+                    packed_block_size,
+                    block_stride,
+                    storage_size);
+            memcpy(dst, src, storage_size);
+        }
     }
 }
 
@@ -204,23 +238,13 @@ void IndexRaBitQFastScan::add(idx_t n, const float* x) {
     compute_codes(tmp_codes.get(), n, x);
 
     const size_t storage_size = compute_per_vector_storage_size();
-    flat_storage.resize((ntotal + n) * storage_size);
-
-    // Populate flat storage (no sign bits copying needed!)
     const size_t bit_pattern_size = (d + 7) / 8;
-    for (idx_t i = 0; i < n; i++) {
-        const uint8_t* code = tmp_codes.get() + i * code_size;
-        const idx_t vec_idx = ntotal + i;
-
-        // Copy factors data directly to flat storage (no reordering needed)
-        const uint8_t* source_factors_ptr = code + bit_pattern_size;
-        uint8_t* storage = flat_storage.data() + vec_idx * storage_size;
-        memcpy(storage, source_factors_ptr, storage_size);
-    }
 
-    // Resize main storage (same logic as parent)
+    // Resize main storage with enlarged block layout
     ntotal2 = roundup(ntotal + n, bbs);
-    size_t new_size = ntotal2 * M2 / 2; // assume nbits = 4
+    const size_t block_stride = get_block_stride();
+    const size_t n_blocks = ntotal2 / bbs;
+    size_t new_size = n_blocks * block_stride;
     size_t old_size = codes.size();
     if (new_size > old_size) {
         codes.resize(new_size);
@@ -230,13 +254,27 @@ void IndexRaBitQFastScan::add(idx_t n, const float* x) {
     // Use our custom packing function with correct stride
     pq4_pack_codes_range(
             tmp_codes.get(),
-            M, // Number of sub-quantizers (bit patterns only)
+            M,
             ntotal,
-            ntotal + n, // Range to pack
+            ntotal + n,
             bbs,
-            M2,          // Block parameters
-            codes.get(), // Output
-            code_size);  // CUSTOM STRIDE: includes factor space
+            M2,
+            codes.get(),
+            code_size,
+            block_stride);
+
+    const size_t packed_block_size = ((M2 + 1) / 2) * bbs;
+    for (idx_t i = 0; i < n; i++) {
+        const uint8_t* src = tmp_codes.get() + i * code_size + bit_pattern_size;
+        uint8_t* dst = rabitq_utils::get_block_aux_ptr(
+                codes.get(),
+                ntotal + i,
+                bbs,
+                packed_block_size,
+                block_stride,
+                storage_size);
+        memcpy(dst, src, storage_size);
+    }
 
     ntotal += n;
 }
@@ -502,7 +540,11 @@ RaBitQHeapHandler<C, with_id_map>::RaBitQHeapHandler(
           nq(nq_val),
           k(k_val),
           context(ctx),
-          is_multi_bit(multi_bit) {
+          is_multi_bit(multi_bit),
+          storage_size(index->compute_per_vector_storage_size()),
+          packed_block_size(((index->M2 + 1) / 2) * index->bbs),
+          full_block_size(index->get_block_stride()),
+          packer(index->get_CodePacker()) {
     // Initialize heaps for all queries in constructor
     // This allows us to support direct normalizer assignment
 #pragma omp parallel for if (nq > 100)
@@ -543,8 +585,11 @@ void RaBitQHeapHandler<C, with_id_map>::handle(
             ? std::min<size_t>(32, rabitq_index->ntotal - base_db_idx)
             : 0;
 
-    // Get storage size once
-    const size_t storage_size = rabitq_index->compute_per_vector_storage_size();
+    // Compute block auxiliary region base pointer once per batch.
+    // Since bbs=32, each batch of 32 vectors aligns to one block.
+    const size_t block_idx = base_db_idx / rabitq_index->bbs;
+    const uint8_t* aux_base = rabitq_index->codes.get() +
+            block_idx * full_block_size + packed_block_size;
 
     // Stats tracking for multi-bit two-stage search only
     // n_1bit_evaluations: candidates evaluated using 1-bit lower bound
@@ -559,9 +604,8 @@ void RaBitQHeapHandler<C, with_id_map>::handle(
         // Normalize distance from LUT lookup
         const float normalized_distance = d32tab[i] * one_a + bias;
 
-        // Access factors from flat storage
-        const uint8_t* base_ptr =
-                rabitq_index->flat_storage.data() + db_idx * storage_size;
+        // Access factors from block auxiliary region
+        const uint8_t* base_ptr = aux_base + i * storage_size;
 
         if (is_multi_bit) {
             // Track candidates actually considered for two-stage filtering
@@ -578,14 +622,16 @@ void RaBitQHeapHandler<C, with_id_map>::handle(
                     rabitq_index->qb,
                     rabitq_index->d);
 
-            float lower_bound = compute_lower_bound(dist_1bit, db_idx, q);
-
             // Adaptive filtering: decide whether to compute full distance
             const bool is_similarity = rabitq_index->metric_type ==
                     MetricType::METRIC_INNER_PRODUCT;
-            bool should_refine = is_similarity
-                    ? (lower_bound > heap_dis[0])  // IP: keep if better
-                    : (lower_bound < heap_dis[0]); // L2: keep if better
+            bool should_refine = rabitq_utils::should_refine_candidate(
+                    dist_1bit,
+                    full_factors.f_error,
+                    context.query_factors ? context.query_factors[q].g_error
+                                          : 0.0f,
+                    heap_dis[0],
+                    is_similarity);
 
             if (should_refine) {
                 local_multibit_evaluations++;
@@ -647,10 +693,14 @@ float RaBitQHeapHandler<C, with_id_map>::compute_lower_bound(
         float dist_1bit,
         size_t db_idx,
         size_t q) const {
-    // Access f_error directly from SignBitFactorsWithError in flat storage
-    const size_t storage_size = rabitq_index->compute_per_vector_storage_size();
-    const uint8_t* base_ptr =
-            rabitq_index->flat_storage.data() + db_idx * storage_size;
+    // Access f_error from block auxiliary region
+    const uint8_t* base_ptr = rabitq_utils::get_block_aux_ptr(
+            rabitq_index->codes.get(),
+            db_idx,
+            rabitq_index->bbs,
+            packed_block_size,
+            full_block_size,
+            storage_size);
     const SignBitFactorsWithError& db_factors =
             *reinterpret_cast<const SignBitFactorsWithError*>(base_ptr);
     float f_error = db_factors.f_error;
@@ -674,9 +724,13 @@ float RaBitQHeapHandler<C, with_id_map>::compute_full_multibit_distance(
     const size_t ex_bits = rabitq_index->rabitq.nb_bits - 1;
     const size_t dim = rabitq_index->d;
 
-    const size_t storage_size = rabitq_index->compute_per_vector_storage_size();
-    const uint8_t* base_ptr =
-            rabitq_index->flat_storage.data() + db_idx * storage_size;
+    const uint8_t* base_ptr = rabitq_utils::get_block_aux_ptr(
+            rabitq_index->codes.get(),
+            db_idx,
+            rabitq_index->bbs,
+            packed_block_size,
+            full_block_size,
+            storage_size);
 
     const size_t ex_code_size = (dim * ex_bits + 7) / 8;
     const uint8_t* ex_code = base_ptr + sizeof(SignBitFactorsWithError);
@@ -689,8 +743,7 @@ float RaBitQHeapHandler<C, with_id_map>::compute_full_multibit_distance(
 
     // Get sign bits from FastScan packed format
     std::vector<uint8_t> unpacked_code(rabitq_index->code_size);
-    CodePackerPQ4 packer(rabitq_index->M2, rabitq_index->bbs);
-    packer.unpack_1(rabitq_index->codes.get(), db_idx, unpacked_code.data());
+    packer->unpack_1(rabitq_index->codes.get(), db_idx, unpacked_code.data());
     const uint8_t* sign_bits = unpacked_code.data();
 
     return rabitq_utils::compute_full_multibit_distance(
@@ -698,8 +751,9 @@ float RaBitQHeapHandler<C, with_id_map>::compute_full_multibit_distance(
             ex_code,
             ex_fac,
             query_factors.rotated_q.data(),
-            query_factors.qr_to_c_L2sqr,
-            query_factors.qr_norm_L2sqr,
+            (rabitq_index->metric_type == MetricType::METRIC_INNER_PRODUCT)
+                    ? query_factors.q_dot_c
+                    : query_factors.qr_to_c_L2sqr,
             dim,
             ex_bits,
             rabitq_index->metric_type);

data/vendor/faiss/faiss/IndexRaBitQFastScan.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <memory>
 #include <vector>
 
 #include <faiss/IndexFastScan.h>
@@ -43,17 +44,6 @@ struct IndexRaBitQFastScan : IndexFastScan {
     /// Center of all points (same as IndexRaBitQ)
     std::vector<float> center;
 
-    /// Per-vector auxiliary data (1-bit codes stored separately in `codes`)
-    ///
-    /// 1-bit codes (sign bits) are stored in the inherited `codes` array from
-    /// IndexFastScan in packed FastScan format for SIMD processing.
-    ///
-    /// This flat_storage holds per-vector factors and refinement-bit codes:
-    /// Layout for 1-bit: [SignBitFactors (8 bytes)]
-    /// Layout for multi-bit: [SignBitFactorsWithError
-    /// (12B)][ref_codes][ExtraBitsFactors (8B)]
-    std::vector<uint8_t> flat_storage;
-
     /// Default number of bits to quantize a query with
     uint8_t qb = 8;
 
@@ -77,7 +67,7 @@ struct IndexRaBitQFastScan : IndexFastScan {
 
     void compute_codes(uint8_t* codes, idx_t n, const float* x) const override;
 
-    /// Compute storage size per vector in flat_storage
+    /// Compute per-vector auxiliary data size in block aux region
     size_t compute_per_vector_storage_size() const;
 
     void compute_float_LUT(
@@ -88,6 +78,12 @@ struct IndexRaBitQFastScan : IndexFastScan {
 
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
 
+    /// Return CodePackerRaBitQ with enlarged block size
+    CodePacker* get_CodePacker() const override;
+
+    /// Remove vectors and compact both PQ4 codes and auxiliary data
+    size_t remove_ids(const IDSelector& sel) override;
+
     void search(
             idx_t n,
             const float* x,
@@ -141,6 +137,12 @@ struct RaBitQHeapHandler
             context;         // Processing context with query offset
     const bool is_multi_bit; // Runtime flag for multi-bit mode
 
+    // Cached block-layout constants (invariant for handler lifetime)
+    const size_t storage_size;
+    const size_t packed_block_size;
+    const size_t full_block_size;
+    std::unique_ptr<CodePacker> packer; // cached for unpack in hot path
+
     // Use float-based comparator for heap operations
     using Cfloat = typename std::conditional<
             C::is_max,