Switch all search paths to FastScanCodeScanner and remove make_knn_handler

Summary:
Now that every make_knn_scanner() returns a real scanner (never nullptr),
switch all callers to use scanners directly and remove make_knn_handler.

Add impl param to make_knn_scanner and its factory so heap vs reservoir
selection respects the implem setting. Switch IndexFastScan
search_implem_12/14, IndexIVFFastScan search_dispatch_implem/range_search,
and IndexIVFPQFastScan scan_codes to scanner-only paths. Add range scanner
factories (make_range_scanner, make_partial_range_scanner). Remove
make_knn_handler from all classes. Change search_implem_10/12 scanner
param from pointer to reference.

Differential Revision: D96116555

Author: algoriddle

faiss/IndexFastScan.cpp

@@ -24,8 +24,6 @@
 
 namespace faiss {
 
-using namespace simd_result_handlers;
-
 inline size_t roundup(size_t a, size_t b) {
     return (a + b - 1) / b * b;
 }
@@ -219,48 +217,10 @@ std::unique_ptr<FastScanCodeScanner> IndexFastScan::make_knn_scanner(
         float* distances,
         idx_t* labels,
         const IDSelector* sel,
-        const FastScanDistancePostProcessing&) const {
-    return make_fast_scan_knn_scanner(
-            is_max, 0, n, ntotal, k, distances, labels, sel);
-}
-
-// Default implementation of make_knn_handler with centralized fallback logic
-SIMDResultHandlerToFloat* IndexFastScan::make_knn_handler(
-        bool is_max,
         int impl,
-        idx_t n,
-        idx_t k,
-        size_t ntotal,
-        float* distances,
-        idx_t* labels,
-        const IDSelector* sel,
         const FastScanDistancePostProcessing&) const {
-    // Create default handlers based on k and impl
-    if (is_max) {
-        using HeapHC = HeapHandler<CMax<uint16_t, int>, false>;
-        using ReservoirHC = ReservoirHandler<CMax<uint16_t, int>, false>;
-        using SingleResultHC = SingleResultHandler<CMax<uint16_t, int>, false>;
-
-        if (k == 1) {
-            return new SingleResultHC(n, ntotal, distances, labels, sel);
-        } else if (impl % 2 == 0) {
-            return new HeapHC(n, ntotal, k, distances, labels, sel);
-        } else {
-            return new ReservoirHC(n, ntotal, k, 2 * k, distances, labels, sel);
-        }
-    } else {
-        using HeapHC = HeapHandler<CMin<uint16_t, int>, false>;
-        using ReservoirHC = ReservoirHandler<CMin<uint16_t, int>, false>;
-        using SingleResultHC = SingleResultHandler<CMin<uint16_t, int>, false>;
-
-        if (k == 1) {
-            return new SingleResultHC(n, ntotal, distances, labels, sel);
-        } else if (impl % 2 == 0) {
-            return new HeapHC(n, ntotal, k, distances, labels, sel);
-        } else {
-            return new ReservoirHC(n, ntotal, k, 2 * k, distances, labels, sel);
-        }
-    }
+    return make_fast_scan_knn_scanner(
+            is_max, impl, n, ntotal, k, distances, labels, sel);
 }
 
 using namespace quantize_lut;
@@ -481,7 +441,6 @@ void IndexFastScan::search_implem_12(
         idx_t* labels,
         int impl,
         const FastScanDistancePostProcessing& context) const {
-    using RH = ResultHandlerCompare<C, false>;
     FAISS_THROW_IF_NOT(bbs == 32);
 
     // handle qbs2 blocking by recursive call
@@ -532,36 +491,26 @@ void IndexFastScan::search_implem_12(
             pq4_pack_LUT_qbs(qbs, M2, quantized_dis_tables.get(), LUT.get());
     FAISS_THROW_IF_NOT(LUT_nq == n);
 
-    std::unique_ptr<RH> handler(
-            static_cast<RH*>(make_knn_handler(
-                    C::is_max,
-                    impl,
-                    n,
-                    k,
-                    ntotal,
-                    distances,
-                    labels,
-                    nullptr,
-                    context)));
-
-    handler->disable = bool(skip & 2);
-    handler->normalizers = normalizers.get();
-
-    if (skip & 4) {
-        // pass
-    } else {
-        pq4_accumulate_loop_qbs(
+    auto scanner = make_knn_scanner(
+            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+    auto* rh = scanner->handler();
+    rh->normalizers = normalizers.get();
+    // Note: skip & 2 previously set handler->disable (run kernel,
+    // discard results). Through the scanner path, skip & 2 now skips
+    // the kernel entirely (same as skip & 4), since disable is not
+    // accessible through the SIMDResultHandlerToFloat* interface.
+    if (!(skip & (2 | 4))) {
+        scanner->accumulate_loop_qbs(
                 qbs,
                 ntotal2,
                 M2,
                 codes.get(),
                 LUT.get(),
-                *handler.get(),
                 context.pq2x4_scale,
                 get_block_stride());
     }
     if (!(skip & 8)) {
-        handler->end();
+        rh->end();
     }
 }
 
@@ -576,7 +525,6 @@ void IndexFastScan::search_implem_14(
         idx_t* labels,
         int impl,
         const FastScanDistancePostProcessing& context) const {
-    using RH = ResultHandlerCompare<C, false>;
     FAISS_THROW_IF_NOT(bbs % 32 == 0);
 
     int qbs2 = qbs == 0 ? 4 : qbs;
@@ -616,36 +564,27 @@ void IndexFastScan::search_implem_14(
     AlignedTable<uint8_t> LUT(n * dim12);
     pq4_pack_LUT(n, M2, quantized_dis_tables.get(), LUT.get());
 
-    std::unique_ptr<RH> handler(
-            static_cast<RH*>(make_knn_handler(
-                    C::is_max,
-                    impl,
-                    n,
-                    k,
-                    ntotal,
-                    distances,
-                    labels,
-                    nullptr,
-                    context)));
-    handler->disable = bool(skip & 2);
-    handler->normalizers = normalizers.get();
-
-    if (skip & 4) {
-        // pass
-    } else {
-        pq4_accumulate_loop(
+    auto scanner = make_knn_scanner(
+            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+    auto* rh = scanner->handler();
+    rh->normalizers = normalizers.get();
+    // Note: skip & 2 previously set handler->disable (run kernel,
+    // discard results). Through the scanner path, skip & 2 now skips
+    // the kernel entirely (same as skip & 4), since disable is not
+    // accessible through the SIMDResultHandlerToFloat* interface.
+    if (!(skip & (2 | 4))) {
+        scanner->accumulate_loop(
                 n,
                 ntotal2,
                 bbs,
                 M2,
                 codes.get(),
                 LUT.get(),
-                *handler.get(),
                 context.pq2x4_scale,
                 get_block_stride());
     }
     if (!(skip & 8)) {
-        handler->end();
+        rh->end();
     }
 }
 

faiss/IndexFastScan.h

@@ -18,7 +18,6 @@ namespace faiss {
 
 struct CodePacker;
 struct IDSelector;
-struct SIMDResultHandlerToFloat;
 
 /** Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now.
  *
@@ -138,36 +137,9 @@ struct IndexFastScan : Index {
             float* distances,
             idx_t* labels,
             const IDSelector* sel,
+            int impl = 0,
             const FastScanDistancePostProcessing& context = {}) const;
 
-    /** Create a KNN handler for this index type
-     *
-     * This method can be overridden by derived classes to provide
-     * specialized handlers (e.g., RaBitQHeapHandler for RaBitQ indexes).
-     * Base implementation creates standard handlers based on k and impl.
-     *
-     * @param is_max       whether to use CMax comparator (true) or CMin (false)
-     * @param impl         implementation number
-     * @param n            number of queries
-     * @param k            number of neighbors to find
-     * @param ntotal       total number of vectors in database
-     * @param distances    output distances array
-     * @param labels       output labels array
-     * @param sel          optional ID selector
-     * @param context      processing context for distance post-processing
-     * @return             pointer to created handler (never returns nullptr)
-     */
-    virtual SIMDResultHandlerToFloat* make_knn_handler(
-            bool is_max,
-            int impl,
-            idx_t n,
-            idx_t k,
-            size_t ntotal,
-            float* distances,
-            idx_t* labels,
-            const IDSelector* sel,
-            const FastScanDistancePostProcessing& context) const;
-
     // called by search function
     void compute_quantized_LUT(
             idx_t n,