faiss 0.6.3 → 0.6.4

data/vendor/faiss/faiss/impl/HNSW.h

@@ -7,8 +7,10 @@
 
 #pragma once
 
+#include <functional>
 #include <optional>
 #include <queue>
+#include <utility>
 #include <vector>
 
 #include <omp.h>
@@ -152,8 +154,14 @@ struct HNSW {
     /// use bounded queue during exploration
     bool search_bounded_queue = true;
 
-    /// use Panorama progressive pruning in search
-    bool is_panorama = false;
+    /// Specialized level-0 search implementations. This state is derived from
+    /// the owning IndexHNSW subtype after construction or deserialization.
+    enum Search_method_t : uint8_t {
+        SM_DEFAULT,
+        SM_PANORAMA,
+        SM_RABITQ,
+    };
+    Search_method_t search_method = SM_DEFAULT;
 
     /// distance comparison semantics: when true, distances are treated as
     /// similarity scores (larger is better). Default false matches the
@@ -204,14 +212,27 @@ struct HNSW {
             VisitedTable& vt,
             bool keep_max_size_level0 = false);
 
-    /** add point pt_id on all levels <= pt_level and build the link
-     * structure for them. */
-    void add_with_locks(
+    /** Deterministic build, phase A: write pt_id's forward links against an
+     * immutable snapshot, touching only pt_id's own slots. Reciprocal edges
+     * are collected in `pt_reverse_edges` for phase B, not applied. Requires
+     * entry_point set. */
+    void compute_forward_links_deterministic(
             DistanceComputer& ptdis,
             int pt_level,
-            int pt_id,
-            LockVector& locks,
+            storage_idx_t pt_id,
             VisitedTable& vt,
+            std::vector<std::pair<storage_idx_t, int>>& pt_reverse_edges,
+            bool keep_max_size_level0 = false);
+
+    /** Deterministic build, phase B: merge `incoming` into `node` and
+     * re-prune in a total order (distance, ties by id) so the result is
+     * order-independent. Touches only `node`'s slots; `incoming` is sorted
+     * and deduplicated in place. */
+    void merge_reverse_links_deterministic(
+            DistanceComputer& dis,
+            storage_idx_t node,
+            int level,
+            std::vector<storage_idx_t>& incoming,
             bool keep_max_size_level0 = false);
 
     /// Search interface for 1 point, single thread
@@ -257,6 +278,24 @@ struct HNSW {
     void permute_entries(const idx_t* map);
 };
 
+/** Deterministic, lock-free HNSW graph build. This is the only graph build
+ * that add() uses, and it is shared by IndexHNSW and
+ * IndexBinaryHNSW. The callbacks let both share the algorithm:
+ * `make_distance_computer()` returns a fresh DistanceComputer per thread
+ * (caller-owned) and `set_query(dc, pt_id)` points it at pt_id's vector. */
+void hnsw_add_vertices_deterministic(
+        HNSW& hnsw,
+        size_t n0,
+        size_t n,
+        int d,
+        bool init_level0,
+        bool keep_max_size_level0,
+        bool preset_levels,
+        bool verbose,
+        const std::function<DistanceComputer*()>& make_distance_computer,
+        const std::function<void(DistanceComputer&, HNSW::storage_idx_t)>&
+                set_query);
+
 struct HNSWStats {
     size_t n1 = 0; /// number of vectors searched
     size_t n2 =

data/vendor/faiss/faiss/impl/IDSelector.h

@@ -23,6 +23,50 @@ struct IDSelector {
     virtual ~IDSelector() {}
 };
 
+/** Scan context handed to IDSelectorWithContext::is_member_with_context: the
+ * contiguous id block being scanned and the position of the id under test. */
+struct IDScanContext {
+    /// the contiguous block of ids being scanned
+    const idx_t* ids;
+    /// number of entries in `ids`
+    size_t list_size;
+    /// index of the tested id within `ids` (i.e. ids[j] == id)
+    size_t j;
+};
+
+/** IDSelector that also receives the surrounding scan context on each
+ * membership test, letting an implementation exploit locality across a scan
+ * (for example, prefetching data for an entry it will be asked about soon).
+ * The policy is entirely up to the implementation. */
+struct IDSelectorWithContext : IDSelector {
+    virtual bool is_member_with_context(idx_t id, const IDScanContext& ctx)
+            const = 0;
+};
+
+/** Routes each per-candidate membership test to is_member_with_context() when
+ * the selector implements IDSelectorWithContext, else to plain is_member().
+ * Construct one per inverted-list scan: the dynamic_cast is the only RTTI cost
+ * and the per-candidate cost is a single predicted branch (cf. the
+ * IDSelectorRange dynamic_cast in IndexIVF.cpp). The scan context is only
+ * meaningful when the scan exposes a real id array (i.e. !store_pairs); when
+ * store_pairs the context path is disabled and every test falls back to
+ * is_member. */
+struct IDSelectorContextDispatch {
+    const IDSelector* sel;
+    const IDSelectorWithContext* ctx_sel;
+
+    IDSelectorContextDispatch(const IDSelector* sel, bool store_pairs)
+            : sel(sel),
+              ctx_sel((sel != nullptr && !store_pairs)
+                              ? dynamic_cast<const IDSelectorWithContext*>(sel)
+                              : nullptr) {}
+
+    bool is_member(idx_t id, const IDScanContext& ctx) const {
+        return ctx_sel ? ctx_sel->is_member_with_context(id, ctx)
+                       : sel->is_member(id);
+    }
+};
+
 /** ids between [imin, imax) */
 struct IDSelectorRange : IDSelector {
     idx_t imin, imax;

data/vendor/faiss/faiss/impl/NNDescent.cpp

@@ -264,6 +264,8 @@ void NNDescent::update() {
             auto& nn_new = node.nn_new;
             auto& nn_old = node.nn_old;
 
+            // other.pool.back() below is read without other.lock: in this
+            // phase no thread reorders or resizes a pool. Lock guards rnn_*.
             for (int l = 0; l < node.M; ++l) {
                 auto& nn = node.pool[l];
                 auto& other = graph[nn.id]; // the other side of the edge
@@ -283,7 +285,6 @@ void NNDescent::update() {
                         }
                     }
                     nn.flag = false;
-
                 } else { // the node is old
                     // push the neighbor into nn_old
                     nn_old.push_back(nn.id);
@@ -300,11 +301,17 @@ void NNDescent::update() {
                     }
                 }
             }
-            // make heap to join later (in join() function)
-            std::make_heap(node.pool.begin(), node.pool.end());
         }
     }
 
+    // Restore the max-heap invariant for the next join()'s insert(). Must
+    // stay a separate region: re-heapifying during Step 3 would race with
+    // its unlocked other.pool.back() reads.
+#pragma omp parallel for
+    for (int n = 0; n < ntotal; ++n) {
+        std::make_heap(graph[n].pool.begin(), graph[n].pool.end());
+    }
+
     // Step 4.
     // Combine the forward and the reverse links
     // R = 0 means no reverse links are used.

data/vendor/faiss/faiss/impl/Panorama.h

@@ -235,7 +235,8 @@ inline auto with_bool(bool value, Lambda&& fn) {
  * accelerating the refinement stage.
  */
 struct Panorama {
-    static constexpr size_t kDefaultBatchSize = 128;
+    static constexpr size_t kDefaultBatchSize = 1024;
+    static constexpr size_t kLegacyBatchSize = 128;
 
     size_t d = 0;
     size_t code_size = 0;
@@ -322,12 +323,20 @@ struct Panorama {
         size_t batch_offset = batch_no * batch_size * code_size;
         const uint8_t* storage_base = codes_base + batch_offset;
 
+        // Honor IDSelectorWithContext: the scan-order position within the whole
+        // list is global_idx, so a lookahead crosses batch boundaries correctly
+        // (ids is the full list, length list_size).
+        IDSelectorContextDispatch sel_dispatch(
+                sel, /*store_pairs=*/ids == nullptr);
+
         // Initialize active set with ID-filtered vectors.
         size_t num_active = 0;
         for (size_t i = 0; i < curr_batch_size; i++) {
             size_t global_idx = batch_start + i;
             idx_t id = (ids == nullptr) ? global_idx : ids[global_idx];
-            bool include = !use_sel || sel->is_member(id);
+            bool include = !use_sel ||
+                    sel_dispatch.is_member(
+                            id, IDScanContext{ids, list_size, global_idx});
 
             active_indices[num_active] = i;
             float cum_sum = batch_cum_sums[i];

data/vendor/faiss/faiss/impl/ProductQuantizer.cpp

@@ -280,7 +280,7 @@ void compute_1_code(const ProductQuantizer& pq, const float* x, uint8_t* code) {
 } // namespace
 
 void ProductQuantizer::compute_code(const float* x, uint8_t* code) const {
-    with_simd_level([&]<SIMDLevel SL>() {
+    with_simd_level_with_sve([&]<SIMDLevel SL>() {
         switch (nbits) {
             case 8:
                 compute_1_code<PQEncoder8, SL>(*this, x, code);
@@ -294,7 +294,7 @@ void ProductQuantizer::compute_code(const float* x, uint8_t* code) const {
                 compute_1_code<PQEncoderGeneric, SL>(*this, x, code);
                 break;
         }
-    }); // with_simd_level
+    }); // with_simd_level_with_sve
 }
 
 template <class PQDecoder>
@@ -442,7 +442,7 @@ void ProductQuantizer::compute_codes(const float* x, uint8_t* codes, size_t n)
 
 void ProductQuantizer::compute_distance_table(const float* x, float* dis_table)
         const {
-    with_simd_level([&]<SIMDLevel SL>() {
+    with_simd_level_with_sve([&]<SIMDLevel SL>() {
         if (transposed_centroids.empty()) {
             // use regular version
             for (size_t m = 0; m < M; m++) {
@@ -824,7 +824,7 @@ void ProductQuantizer::compute_sdc_table() {
     sdc_table.resize(M * ksub * ksub);
 
     if (dsub < 4) {
-        with_simd_level([&]<SIMDLevel SL>() {
+        with_simd_level_with_sve([&]<SIMDLevel SL>() {
 #pragma omp parallel for
             for (int64_t mk = 0; mk < static_cast<int64_t>(M * ksub); mk++) {
                 // allow omp to schedule in a more fine-grained way

data/vendor/faiss/faiss/impl/RaBitQUtils.cpp

@@ -329,7 +329,7 @@ float compute_full_multibit_distance(
         size_t d,
         size_t ex_bits,
         MetricType metric_type) {
-    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_BASE_WITH_VPOPCNT>(
             [&]<SIMDLevel SL>() {
                 return compute_full_multibit_distance<SL>(
                         sign_bits,

data/vendor/faiss/faiss/impl/RaBitQuantizer.cpp

@@ -17,6 +17,7 @@
 #include <faiss/utils/distances.h>
 #include <faiss/utils/rabitq_simd.h>
 
+#include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <memory>
@@ -24,6 +25,8 @@
 
 namespace faiss {
 
+RaBitQStats rabitq_stats;
+
 // Import shared utilities from RaBitQUtils
 using rabitq_utils::ExtraBitsFactors;
 using rabitq_utils::QueryFactorsData;
@@ -224,6 +227,51 @@ void RaBitQuantizer::decode_core(
     }
 }
 
+template <SIMDLevel SL>
+float symmetric_dis_1bit(const RaBitQDistanceComputer& dc, idx_t i, idx_t j) {
+    FAISS_THROW_IF_NOT_MSG(
+            dc.metric_type == MetricType::METRIC_L2,
+            "RaBitQ symmetric distance supports only L2");
+    FAISS_ASSERT(i >= 0 && j >= 0);
+    FAISS_ASSERT(dc.codes != nullptr);
+
+    const size_t sign_bytes = (dc.d + 7) / 8;
+    const uint8_t* code_i = dc.codes + static_cast<size_t>(i) * dc.code_size;
+    const uint8_t* code_j = dc.codes + static_cast<size_t>(j) * dc.code_size;
+    const auto* factors_i =
+            reinterpret_cast<const SignBitFactors*>(code_i + sign_bytes);
+    const auto* factors_j =
+            reinterpret_cast<const SignBitFactors*>(code_j + sign_bytes);
+
+    const uint64_t xor_popcount =
+            rabitq::bitwise_xor_dot_product<SL>(code_i, code_j, sign_bytes, 1);
+    const float sign_dot =
+            static_cast<float>(dc.d) - 2.0f * static_cast<float>(xor_popcount);
+
+    // The L2-optimal reconstruction of residual r is alpha * sign(r), where
+    // alpha = ||r||_1 / d. The stored factors give
+    // alpha_i * alpha_j = ||r_i||^2 * ||r_j||^2 /
+    //     (d * dp_multiplier_i * dp_multiplier_j).
+    float cross_term = 0.0f;
+    if (factors_i->dp_multiplier != 0.0f && factors_j->dp_multiplier != 0.0f) {
+        // Dividing each norm first avoids overflowing the product of two
+        // squared norms even when the final distance is representable.
+        const float scaled_norm_i =
+                factors_i->or_minus_c_l2sqr / factors_i->dp_multiplier;
+        const float scaled_norm_j =
+                factors_j->or_minus_c_l2sqr / factors_j->dp_multiplier;
+        cross_term = (scaled_norm_i * (sign_dot / static_cast<float>(dc.d))) *
+                scaled_norm_j;
+    }
+    const float distance = factors_i->or_minus_c_l2sqr +
+            factors_j->or_minus_c_l2sqr - 2.0f * cross_term;
+    return std::max(0.0f, distance);
+}
+
+float RaBitQDistanceComputer::symmetric_dis(idx_t i, idx_t j) {
+    return symmetric_dis_1bit<SIMDLevel::NONE>(*this, i, j);
+}
+
 namespace {
 
 // Distance computers templatized on SIMDLevel to avoid per-call dynamic
@@ -240,6 +288,10 @@ struct RaBitQDistanceComputerNotQ final : RaBitQDistanceComputer {
 
     RaBitQDistanceComputerNotQ() = default;
 
+    float symmetric_dis(idx_t i, idx_t j) final {
+        return symmetric_dis_1bit<SL>(*this, i, j);
+    }
+
     // Compute distance using only 1-bit codes (fast)
     float distance_to_code_1bit_impl(
             const uint8_t* binary_data,
@@ -390,11 +442,17 @@ struct RaBitQDistanceComputerNotQ final : RaBitQDistanceComputer {
         const size_t ex_bits = nb_bits - 1;
         FAISS_ASSERT(ex_bits > 0);
 
+        // Honor IDSelectorWithContext on the multibit path too, so a RaBitQ
+        // index does not silently lose the context hook once nb_bits >= 2 (the
+        // 1-bit path already routes through run_scan_codes1).
+        const IDSelectorContextDispatch sel_dispatch(sel, store_pairs);
+
         size_t nup = 0;
         for (size_t j = 0; j < list_size; j++) {
             if (sel != nullptr) {
                 idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
-                if (!sel->is_member(id)) {
+                if (!sel_dispatch.is_member(
+                            id, IDScanContext{ids, list_size, j})) {
                     codes += code_size;
                     continue;
                 }
@@ -449,6 +507,10 @@ struct RaBitQDistanceComputerQ final : RaBitQDistanceComputer {
 
     RaBitQDistanceComputerQ() = default;
 
+    float symmetric_dis(idx_t i, idx_t j) final {
+        return symmetric_dis_1bit<SL>(*this, i, j);
+    }
+
     // Compute distance using only 1-bit codes (fast)
     float distance_to_code_1bit_impl(
             const uint8_t* binary_data,
@@ -601,11 +663,17 @@ struct RaBitQDistanceComputerQ final : RaBitQDistanceComputer {
         const size_t ex_bits = nb_bits - 1;
         FAISS_ASSERT(ex_bits > 0);
 
+        // Honor IDSelectorWithContext on the multibit path too, so a RaBitQ
+        // index does not silently lose the context hook once nb_bits >= 2 (the
+        // 1-bit path already routes through run_scan_codes1).
+        const IDSelectorContextDispatch sel_dispatch(sel, store_pairs);
+
         size_t nup = 0;
         for (size_t j = 0; j < list_size; j++) {
             if (sel != nullptr) {
                 idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
-                if (!sel->is_member(id)) {
+                if (!sel_dispatch.is_member(
+                            id, IDScanContext{ids, list_size, j})) {
                     codes += code_size;
                     continue;
                 }
@@ -653,12 +721,10 @@ FlatCodesDistanceComputer* RaBitQuantizer::get_distance_computer(
     // call the SIMD-specialized rabitq functions directly (no per-call
     // with_simd_level overhead).
     //
-    // Use A0_SPR (which includes AVX512_SPR) so that on Sapphire Rapids
-    // and later x86 microarchitectures the VPOPCNTDQ-based RaBitQ
-    // specialization in rabitq_avx512_spr.cpp is selected. On AVX-512
-    // CPUs without VPOPCNTDQ, dispatch falls through to the AVX512
-    // specialization in rabitq_avx512.cpp.
-    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+    // VPOPCNT rather than SPR: Ice Lake and Zen 4 have VPOPCNTDQ without the
+    // rest of the SPR feature set. Below it, dispatch falls through to
+    // rabitq_avx512.cpp.
+    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_BASE_WITH_VPOPCNT>(
             [&]<SIMDLevel SL>() -> FlatCodesDistanceComputer* {
                 if (qb == 0) {
                     auto dc =

data/vendor/faiss/faiss/impl/RaBitQuantizer.h

@@ -13,6 +13,8 @@
 #include <faiss/MetricType.h>
 #include <faiss/impl/DistanceComputer.h>
 #include <faiss/impl/Quantizer.h>
+#include <faiss/impl/RaBitQUtils.h>
+#include <faiss/impl/platform_macros.h>
 
 namespace faiss {
 
@@ -20,6 +22,31 @@ struct IDSelector;
 template <typename T, typename TI>
 struct ResultHandlerUnordered;
 
+/** Statistics for staged RaBitQ distance evaluation.
+ *
+ * These counters belong to the quantizer rather than to a particular ANN
+ * graph. They are currently populated by HNSW's staged search path.
+ */
+struct RaBitQStats {
+    uint64_t n_1bit = 0;
+    uint64_t n_refine = 0;
+
+    void reset() {
+        n_1bit = n_refine = 0;
+    }
+
+    void add(const RaBitQStats& other) {
+        n_1bit += other.n_1bit;
+        n_refine += other.n_refine;
+    }
+
+    double refine_ratio() const {
+        return n_1bit ? double(n_refine) / double(n_1bit) : 0.0;
+    }
+};
+
+FAISS_API extern RaBitQStats rabitq_stats;
+
 // the reference implementation of the https://arxiv.org/pdf/2405.12497
 //   Jianyang Gao, Cheng Long, "RaBitQ: Quantizing High-Dimensional Vectors
 //   with a Theoretical Error Bound for Approximate Nearest Neighbor Search".
@@ -122,10 +149,10 @@ struct RaBitQDistanceComputer : FlatCodesDistanceComputer {
     // Used with f_error to compute error bounds for two-stage filtering
     float g_error = 0.0f;
 
-    float symmetric_dis(idx_t /*i*/, idx_t /*j*/) override {
-        // Not used for RaBitQ
-        FAISS_THROW_MSG("Not implemented");
-    }
+    /// Per-distance-computer counters, aggregated by the owning index.
+    RaBitQStats stats;
+
+    float symmetric_dis(idx_t i, idx_t j) override;
 
     // Compute 1-bit distance estimate (fast)
     virtual float distance_to_code_1bit(const uint8_t* code) = 0;
@@ -133,6 +160,22 @@ struct RaBitQDistanceComputer : FlatCodesDistanceComputer {
     // Compute full multi-bit distance (accurate)
     virtual float distance_to_code_full(const uint8_t* code) = 0;
 
+    /// Apply the RaBitQ error bound without exposing the packed code layout to
+    /// ANN consumers. Precondition: nb_bits >= 2.
+#ifndef SWIG
+    FAISS_ALWAYS_INLINE bool should_refine(
+            const uint8_t* code,
+            float estimate,
+            float threshold,
+            bool is_similarity) const {
+        const auto* factors =
+                reinterpret_cast<const rabitq_utils::SignBitFactorsWithError*>(
+                        code + (d + 7) / 8);
+        return rabitq_utils::should_refine_candidate(
+                estimate, factors->f_error, g_error, threshold, is_similarity);
+    }
+#endif
+
     virtual void set_centroid(const float* centroid_in) {
         centroid = centroid_in;
     }

data/vendor/faiss/faiss/impl/RaBitQuantizerMultiBit.cpp

@@ -302,9 +302,9 @@ void quantize_ex_bits(
     }
 
     // Step 6: Handle negative dimensions (flip bits)
-    // For negative residuals, flip all bits: code' = ~code & max_code
+    // For negative or zero residuals, flip all bits: code' = ~code & max_code
     for (size_t i = 0; i < d; i++) {
-        if (residual[i] < 0) {
+        if (residual[i] <= 0) {
             tmp_code[i] = (~tmp_code[i]) & max_code;
         }
     }

data/vendor/faiss/faiss/impl/ResultHandler.h

@@ -123,14 +123,20 @@ struct SingleQueryBlockResultHandler : BlockResultHandler<C, use_sel> {
         using ResultHandlerT<C>::threshold;
 
         explicit SingleResultHandler(SingleQueryBlockResultHandler& hr)
-                : the_handler(hr.the_handler) {}
+                : the_handler(hr.the_handler) {
+            threshold = the_handler.threshold;
+        }
 
         /// begin results for query # i
-        void begin(const size_t /* qid */) {}
+        void begin(const size_t /* qid */) {
+            threshold = the_handler.threshold;
+        }
 
         /// add one result for query i
         bool add_result(T dis, TI idx) final {
-            return the_handler.add_result(dis, idx);
+            bool updated = the_handler.add_result(dis, idx);
+            threshold = the_handler.threshold;
+            return updated;
         }
 
         /// series of results for query i is done

data/vendor/faiss/faiss/impl/ScalarQuantizer.cpp

@@ -7,6 +7,7 @@
 
 // -*- c++ -*-
 
+#include <cmath>
 #include <cstring>
 #include <memory>
 
@@ -425,14 +426,29 @@ const LloydMaxTable kLloydMaxTables[] = {
         {kLloydMaxCentroids8, kLloydMaxBoundaries8}, // 8
 };
 
-void populate_lloyd_max_trained(size_t mse_bits, std::vector<float>& trained) {
+// The tables are Lloyd-Max optimal for N(0, 1) input. Callers whose input has
+// a different standard deviation pass it as `scale` to stretch the table.
+void populate_lloyd_max_trained(
+        size_t mse_bits,
+        std::vector<float>& trained,
+        float scale = 1.0f) {
     FAISS_THROW_IF_NOT(mse_bits >= 1 && mse_bits <= 8);
     FAISS_THROW_IF_NOT(kLloydMaxTables[mse_bits].centroids);
     size_t k = size_t(1) << mse_bits;
     const auto& t = kLloydMaxTables[mse_bits];
     trained.resize(k + (k - 1));
-    std::copy(t.centroids, t.centroids + k, trained.begin());
-    std::copy(t.boundaries, t.boundaries + k - 1, trained.begin() + k);
+    for (size_t i = 0; i < k; i++) {
+        trained[i] = t.centroids[i] * scale;
+    }
+    for (size_t i = 0; i + 1 < k; i++) {
+        trained[k + i] = t.boundaries[i] * scale;
+    }
+}
+
+// Component scale of a unit-norm vector in R^d.
+float unit_norm_component_scale(size_t d) {
+    FAISS_THROW_IF_NOT(d > 0);
+    return 1.0f / std::sqrt(static_cast<float>(d));
 }
 
 } // namespace
@@ -588,19 +604,24 @@ void ScalarQuantizer::train(size_t n, const float* x) {
             populate_lloyd_max_trained(bits, trained);
             break;
         case QT_1bit_tqmse:
-            populate_lloyd_max_trained(1, trained);
+            populate_lloyd_max_trained(
+                    1, trained, unit_norm_component_scale(d));
             break;
         case QT_2bit_tqmse:
-            populate_lloyd_max_trained(2, trained);
+            populate_lloyd_max_trained(
+                    2, trained, unit_norm_component_scale(d));
             break;
         case QT_3bit_tqmse:
-            populate_lloyd_max_trained(3, trained);
+            populate_lloyd_max_trained(
+                    3, trained, unit_norm_component_scale(d));
             break;
         case QT_4bit_tqmse:
-            populate_lloyd_max_trained(4, trained);
+            populate_lloyd_max_trained(
+                    4, trained, unit_norm_component_scale(d));
             break;
         case QT_8bit_tqmse:
-            populate_lloyd_max_trained(8, trained);
+            populate_lloyd_max_trained(
+                    8, trained, unit_norm_component_scale(d));
             break;
         case QT_2bit_tq:
         case QT_3bit_tq:
@@ -614,7 +635,6 @@ void ScalarQuantizer::train(size_t n, const float* x) {
             trained.push_back(seed_f[0]);
             trained.push_back(seed_f[1]);
             trained.push_back(static_cast<float>(turboq_refine.qjl_type));
-            turboq_refine.init_projection(d);
             break;
         }
         default:
@@ -622,29 +642,11 @@ void ScalarQuantizer::train(size_t n, const float* x) {
     }
 }
 
-void ScalarQuantizer::TurboQuantRefine::init_projection(size_t d) {
-    if (use_fwht()) {
-        padded_d = 1;
-        while (padded_d < d) {
-            padded_d <<= 1;
-        }
-        fwht_signs.resize(padded_d);
-        RandomGenerator rng(seed);
-        for (size_t i = 0; i < padded_d; i++) {
-            fwht_signs[i] = (rng.rand_int(2) == 0) ? 1.0f : -1.0f;
-        }
-    } else {
-        rr_matrix.resize(d * d);
-        float_randn(rr_matrix.data(), d * d, seed);
-        matrix_qr(static_cast<int>(d), static_cast<int>(d), rr_matrix.data());
-    }
-}
-
 ScalarQuantizer::SQuantizer* ScalarQuantizer::select_quantizer() const {
     // A SIMD level's factory returns nullptr when the dimension is
     // incompatible (e.g. AVX-512 needs d % 16 == 0); the dispatcher then falls
     // back to the next-lower level (AVX-512 -> AVX2 -> scalar).
-    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_BASE_WITH_SPR>(
             [&]<SIMDLevel SL>() -> SQuantizer* {
                 return scalar_quantizer::sq_select_quantizer<SL>(
                         qtype, d, trained);
@@ -681,7 +683,7 @@ void ScalarQuantizer::decode(const uint8_t* codes, float* x, size_t n) const {
 ScalarQuantizer::SQDistanceComputer* ScalarQuantizer::get_distance_computer(
         MetricType metric) const {
     FAISS_THROW_IF_NOT(metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT);
-    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_BASE_WITH_SPR>(
             [&]<SIMDLevel SL>() -> SQDistanceComputer* {
                 return scalar_quantizer::sq_select_distance_computer<SL>(
                         metric, qtype, d, trained);
@@ -694,7 +696,7 @@ InvertedListScanner* ScalarQuantizer::select_InvertedListScanner(
         bool store_pairs,
         const IDSelector* sel,
         bool by_residual) const {
-    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+    return with_simd_level_fallback<AVAILABLE_SIMD_LEVELS_BASE_WITH_SPR>(
             [&]<SIMDLevel SL>() -> InvertedListScanner* {
                 return scalar_quantizer::sq_select_InvertedListScanner<SL>(
                         qtype,

data/vendor/faiss/faiss/impl/ScalarQuantizer.h

@@ -177,18 +177,9 @@ struct ScalarQuantizer : Quantizer {
             return s;
         }
 
+        /// The selected projection is built from `trained` by the quantizer.
         uint8_t qjl_type = 0;
         uint64_t seed = 42;
-        size_t padded_d = 0;
-        std::vector<float> fwht_signs;
-        std::vector<float> rr_matrix;
-        size_t nb_bits_lo = 0;
-        size_t n_hi_dims = 0;
-
-        void init_projection(size_t d);
-        bool use_fwht() const {
-            return qjl_type == 0;
-        }
 
         struct DistanceComputer : SQDistanceComputer {
             virtual void configure(uint8_t qb, bool int_qjl) = 0;
@@ -199,6 +190,11 @@ struct ScalarQuantizer : Quantizer {
         };
     };
 
+    static_assert(
+            sizeof(TurboQuantRefine) <= 16,
+            "keep this a small config struct -- do not add projection buffers "
+            "here (T287092602)");
+
     TurboQuantRefine turboq_refine;
 
     SQDistanceComputer* get_distance_computer(