faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/impl/{simd_result_handlers.h → fast_scan/simd_result_handlers.h}

@@ -9,10 +9,11 @@
 
 #include <algorithm>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
+#include <faiss/impl/simdlib/simdlib_dispatch.h>
 #include <faiss/utils/Heap.h>
-#include <faiss/utils/simdlib.h>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
@@ -26,49 +27,109 @@
 
 namespace faiss {
 
-struct SIMDResultHandler {
+namespace {
+
+// a helper that checks whether a ResultHandler has a .sel member
+template <typename T, typename = void>
+struct has_sel_member : std::false_type {};
+template <typename T>
+struct has_sel_member<T, std::void_t<decltype(T::sel)>> : std::true_type {};
+template <typename T>
+inline constexpr bool has_sel_member_v = has_sel_member<T>::value;
+
+/// Check if all vectors in a block are filtered out by the IDSelector.
+/// Returns true if the block should be skipped (all vectors filtered).
+/// Requires set_block_origin() to have been called before this.
+/// Compiles to nothing (returns false) when ResultHandler has no sel member.
+template <class ResultHandler>
+inline bool whether_all_vectors_filtered_out(
+        ResultHandler& res,
+        size_t block_size) {
+    if constexpr (!has_sel_member_v<ResultHandler>) {
+        return false;
+    }
+    if (res.sel != nullptr) {
+        for (size_t jj = 0; jj < block_size; jj++) {
+            if (res.sel->is_member(res.adjust_id(0, jj))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+/// Loop over blocks of Step vectors, advancing codes by block_stride each
+/// iteration. Calls set_block_origin(0, j0) and skips blocks where all
+/// vectors are filtered out. The body lambda receives j0.
+template <size_t Step, class ResultHandler, class Body>
+inline void for_each_block(
+        size_t ntotal,
+        const uint8_t*& codes,
+        size_t block_stride,
+        ResultHandler& res,
+        Body&& body) {
+    for (size_t j0 = 0; j0 < ntotal; j0 += Step, codes += block_stride) {
+        res.set_block_origin(0, j0);
+        if constexpr (has_sel_member_v<ResultHandler>) {
+            if (whether_all_vectors_filtered_out(
+                        res, std::min<size_t>(Step, res.ntotal - j0))) {
+                continue;
+            }
+        }
+        body(j0);
+    }
+}
+
+} // namespace
+
+/* Result handler that will return float results eventually.
+ * Non-template base so it can serve as a polymorphic interface
+ * (e.g. FastScanCodeScanner::handler() returns SIMDResultHandlerToFloat*). */
+struct SIMDResultHandlerToFloat {
     // used to dispatch templates
     bool is_CMax = false;
     uint8_t sizeof_ids = 0;
     bool with_fields = false;
 
-    /**  called when 32 distances are computed and provided in two
-     *   simd16uint16. (q, b) indicate which entry it is in the block. */
-    virtual void handle(
-            size_t q,
-            size_t b,
-            simd16uint16 d0,
-            simd16uint16 d1) = 0;
-
-    /// set the sub-matrix that is being computed
-    virtual void set_block_origin(size_t i0, size_t j0) = 0;
-
-    virtual ~SIMDResultHandler() {}
-};
+    // the number of elements that were successfully processed up to date,
+    //   for example, hitting the threshold for the range search.
+    // the variable is used to track whether an early stop condition
+    //   should be hit due to having zero search progress.
+    size_t in_range_num = 0;
 
-/* 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
+    size_t nq = 0;     // number of queries
+    size_t ntotal = 0; // ignore excess elements after ntotal
 
     /// these fields are used mainly for the IVF variants (with_id_map=true)
     const idx_t* id_map = nullptr; // map offset in invlist to vector id
     const int* q_map = nullptr;    // map q to global query
+    const uint8_t* list_codes_ptr = nullptr; // raw block data for current list
     const uint16_t* dbias =
             nullptr; // table of biases to add to each query (for IVF L2 search)
     const float* normalizers = nullptr; // size 2 * nq, to convert
 
+    size_t scan_cnt = 0; // scanned vector number (except filtered)
+
+    SIMDResultHandlerToFloat() = default;
     SIMDResultHandlerToFloat(size_t nq, size_t ntotal)
             : nq(nq), ntotal(ntotal) {}
 
     virtual void begin(const float* norms) {
         normalizers = norms;
+        scan_cnt = 0;
     }
 
     // called at end of search to convert int16 distances to float, before
     // normalizers are deallocated
     virtual void end() {
         normalizers = nullptr;
+        scan_cnt = 0;
+    }
+
+    // Get the number of scanned vectors
+    size_t count_scanned_rows() {
+        return scan_cnt;
     }
 
     // Number of updates made to the underlying data structure.
@@ -88,19 +149,38 @@ struct SIMDResultHandlerToFloat : SIMDResultHandler {
      */
     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
-    }
+            const std::vector<int>& /* probe_map */) {}
+
+    virtual void set_block_origin(size_t i0, size_t j0) = 0;
+
+    virtual ~SIMDResultHandlerToFloat() = default;
 };
 
-FAISS_API extern bool simd_result_handlers_accept_virtual;
+/** SL-specific base: adds virtual handle() whose simd16uint16 type
+ *  matches the SL template parameter. Concrete handlers override
+ *  with `final` so the compiler can devirtualize and inline. */
+template <SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct SIMDResultHandler : SIMDResultHandlerToFloat {
+    using SIMDResultHandlerToFloat::SIMDResultHandlerToFloat;
+
+    static constexpr SIMDLevel SL256 = simd256_level_selector<SL>::value;
+    using simd16uint16 = simd16uint16_tpl<SL256>;
+
+    virtual void handle(
+            size_t /* q */,
+            size_t /* b */,
+            simd16uint16 /* d0 */,
+            simd16uint16 /* d1 */) {}
+};
 
 namespace simd_result_handlers {
 
 /** Dummy structure that just computes a checksum on results
  * (to avoid the computation to be optimized away) */
-struct DummyResultHandler : SIMDResultHandler {
+template <SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct DummyResultHandler : SIMDResultHandler<SL> {
+    using typename SIMDResultHandler<SL>::simd16uint16;
+
     size_t cs = 0;
 
     void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) final {
@@ -108,15 +188,16 @@ struct DummyResultHandler : SIMDResultHandler {
     }
 
     void set_block_origin(size_t, size_t) final {}
-
-    ~DummyResultHandler() {}
 };
 
 /** memorize results in a nq-by-nb matrix.
  *
  * j0 is the current upper-left block of the matrix
  */
-struct StoreResultHandler : SIMDResultHandler {
+template <SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct StoreResultHandler : SIMDResultHandler<SL> {
+    using typename SIMDResultHandler<SL>::simd16uint16;
+
     uint16_t* data;
     size_t ld; // total number of columns
     size_t i0 = 0;
@@ -137,8 +218,10 @@ struct StoreResultHandler : SIMDResultHandler {
 };
 
 /** stores results in fixed-size matrix. */
-template <int NQ, int BB>
-struct FixedStorageHandler : SIMDResultHandler {
+template <int NQ, int BB, SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct FixedStorageHandler : SIMDResultHandler<SL> {
+    using typename SIMDResultHandler<SL>::simd16uint16;
+
     simd16uint16 dis[NQ][BB];
     int i0 = 0;
 
@@ -160,14 +243,13 @@ struct FixedStorageHandler : SIMDResultHandler {
             }
         }
     }
-
-    virtual ~FixedStorageHandler() {}
 };
 
 /** Result handler that compares distances to check if they need to be kept */
-template <class C, bool with_id_map>
-struct ResultHandlerCompare : SIMDResultHandlerToFloat {
+template <class C, bool with_id_map, SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct ResultHandlerCompare : SIMDResultHandler<SL> {
     using TI = typename C::TI;
+    using typename SIMDResultHandler<SL>::simd16uint16;
 
     bool disable = false;
 
@@ -177,7 +259,7 @@ struct ResultHandlerCompare : SIMDResultHandlerToFloat {
     const IDSelector* sel;
 
     ResultHandlerCompare(size_t nq, size_t ntotal, const IDSelector* sel_in)
-            : SIMDResultHandlerToFloat(nq, ntotal), sel{sel_in} {
+            : SIMDResultHandler<SL>(nq, ntotal), sel{sel_in} {
         this->is_CMax = C::is_max;
         this->sizeof_ids = sizeof(typename C::TI);
         this->with_fields = with_id_map;
@@ -192,22 +274,22 @@ struct ResultHandlerCompare : SIMDResultHandlerToFloat {
     void adjust_with_origin(size_t& q, simd16uint16& d0, simd16uint16& d1) {
         q += i0;
 
-        if (dbias) {
-            simd16uint16 dbias16(dbias[q]);
+        if (this->dbias) {
+            simd16uint16 dbias16(this->dbias[q]);
             d0 += dbias16;
             d1 += dbias16;
         }
 
         if (with_id_map) { // FIXME test on q_map instead
-            q = q_map[q];
+            q = this->q_map[q];
         }
     }
 
     // compute and adjust idx
     int64_t adjust_id(size_t b, size_t j) {
         int64_t idx = j0 + 32 * b + j;
-        if (with_id_map) {
-            idx = id_map[idx];
+        if (this->id_map) {
+            idx = this->id_map[idx];
         }
         return idx;
     }
@@ -233,26 +315,28 @@ struct ResultHandlerCompare : SIMDResultHandlerToFloat {
             return 0;
         }
         uint64_t idx = j0 + b * 32;
-        if (idx + 32 > ntotal) {
-            if (idx >= ntotal) {
+        if (idx + 32 > this->ntotal) {
+            if (idx >= this->ntotal) {
                 return 0;
             }
-            int nbit = (ntotal - idx);
+            int nbit = static_cast<int>(this->ntotal - idx);
             lt_mask &= (uint32_t(1) << nbit) - 1;
         }
         return lt_mask;
     }
-
-    virtual ~ResultHandlerCompare() {}
 };
 
 /** Special version for k=1 */
-template <class C, bool with_id_map = false>
-struct SingleResultHandler : ResultHandlerCompare<C, with_id_map> {
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct SingleResultHandler : ResultHandlerCompare<C, with_id_map, SL> {
     using T = typename C::T;
     using TI = typename C::TI;
-    using RHC = ResultHandlerCompare<C, with_id_map>;
+    using RHC = ResultHandlerCompare<C, with_id_map, SL>;
     using RHC::normalizers;
+    using typename RHC::simd16uint16;
 
     std::vector<int16_t> idis;
     float* dis;
@@ -294,10 +378,13 @@ struct SingleResultHandler : ResultHandlerCompare<C, with_id_map> {
                 auto real_idx = this->adjust_id(b, j);
                 lt_mask -= 1 << j;
                 if (this->sel->is_member(real_idx)) {
+                    this->scan_cnt++;
                     T d = d32tab[j];
                     if (C::cmp(idis[q], d)) {
                         idis[q] = d;
                         ids[q] = real_idx;
+
+                        this->in_range_num++;
                     }
                 }
             }
@@ -306,16 +393,19 @@ struct SingleResultHandler : ResultHandlerCompare<C, with_id_map> {
                 // find first non-zero
                 int j = __builtin_ctz(lt_mask);
                 lt_mask -= 1 << j;
+                this->scan_cnt++;
                 T d = d32tab[j];
                 if (C::cmp(idis[q], d)) {
                     idis[q] = d;
                     ids[q] = this->adjust_id(b, j);
+
+                    this->in_range_num++;
                 }
             }
         }
     }
 
-    void end() {
+    void end() override {
         for (size_t q = 0; q < this->nq; q++) {
             if (!normalizers) {
                 dis[q] = idis[q];
@@ -325,16 +415,21 @@ struct SingleResultHandler : ResultHandlerCompare<C, with_id_map> {
                 dis[q] = b + idis[q] * one_a;
             }
         }
+        this->scan_cnt = 0;
     }
 };
 
 /** Structure that collects results in a min- or max-heap */
-template <class C, bool with_id_map = false>
-struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct HeapHandler : ResultHandlerCompare<C, with_id_map, SL> {
     using T = typename C::T;
     using TI = typename C::TI;
-    using RHC = ResultHandlerCompare<C, with_id_map>;
+    using RHC = ResultHandlerCompare<C, with_id_map, SL>;
     using RHC::normalizers;
+    using typename RHC::simd16uint16;
 
     std::vector<uint16_t> idis;
     std::vector<TI> iids;
@@ -406,11 +501,18 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 auto real_idx = this->adjust_id(b, j);
                 lt_mask -= 1 << j;
                 if (this->sel->is_member(real_idx)) {
+                    this->scan_cnt++;
                     T dis_for_j = d32tab[j];
                     if (C::cmp(heap_dis[0], dis_for_j)) {
                         heap_replace_top<C>(
-                                k, heap_dis, heap_ids, dis_for_j, real_idx);
+                                k,
+                                heap_dis,
+                                heap_ids,
+                                dis_for_j,
+                                static_cast<TI>(real_idx));
                         nup++;
+
+                        this->in_range_num++;
                     }
                 }
             }
@@ -419,11 +521,19 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 // find first non-zero
                 int j = __builtin_ctz(lt_mask);
                 lt_mask -= 1 << j;
+                this->scan_cnt++;
                 T dis_for_j = d32tab[j];
                 if (C::cmp(heap_dis[0], dis_for_j)) {
                     int64_t idx = this->adjust_id(b, j);
-                    heap_replace_top<C>(k, heap_dis, heap_ids, dis_for_j, idx);
+                    heap_replace_top<C>(
+                            k,
+                            heap_dis,
+                            heap_ids,
+                            dis_for_j,
+                            static_cast<TI>(idx));
                     nup++;
+
+                    this->in_range_num++;
                 }
             }
         }
@@ -447,6 +557,7 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 heap_ids[j] = heap_ids_in[j];
             }
         }
+        this->scan_cnt = 0;
     }
 
     size_t num_updates() override {
@@ -460,12 +571,16 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
  * reached. Then a partition sort is used to update the threshold. */
 
 /** Handler built from several ReservoirTopN (one per query) */
-template <class C, bool with_id_map = false>
-struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct ReservoirHandler : ResultHandlerCompare<C, with_id_map, SL> {
     using T = typename C::T;
     using TI = typename C::TI;
-    using RHC = ResultHandlerCompare<C, with_id_map>;
+    using RHC = ResultHandlerCompare<C, with_id_map, SL>;
     using RHC::normalizers;
+    using typename RHC::simd16uint16;
 
     size_t capacity; // rounded up to multiple of 16
 
@@ -524,8 +639,11 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
                 auto real_idx = this->adjust_id(b, j);
                 lt_mask -= 1 << j;
                 if (this->sel->is_member(real_idx)) {
+                    this->scan_cnt++;
                     T dis_for_j = d32tab[j];
-                    res.add(dis_for_j, real_idx);
+                    res.add(dis_for_j, static_cast<TI>(real_idx));
+
+                    this->in_range_num++;
                 }
             }
         } else {
@@ -534,7 +652,10 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
                 int j = __builtin_ctz(lt_mask);
                 lt_mask -= 1 << j;
                 T dis_for_j = d32tab[j];
-                res.add(dis_for_j, this->adjust_id(b, j));
+                this->scan_cnt++;
+                res.add(dis_for_j, static_cast<TI>(this->adjust_id(b, j)));
+
+                this->in_range_num++;
             }
         }
     }
@@ -576,6 +697,7 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
             // possibly add empty results
             heap_heapify<Cf>(n - res.i, heap_dis + res.i, heap_ids + res.i);
         }
+        this->scan_cnt = 0;
     }
 };
 
@@ -583,13 +705,17 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
  * have to be scaled using the scaler.
  */
 
-template <class C, bool with_id_map = false>
-struct RangeHandler : ResultHandlerCompare<C, with_id_map> {
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct RangeHandler : ResultHandlerCompare<C, with_id_map, SL> {
     using T = typename C::T;
     using TI = typename C::TI;
-    using RHC = ResultHandlerCompare<C, with_id_map>;
+    using RHC = ResultHandlerCompare<C, with_id_map, SL>;
     using RHC::normalizers;
     using RHC::nq;
+    using typename RHC::simd16uint16;
 
     RangeSearchResult& rres;
     float radius;
@@ -616,7 +742,7 @@ struct RangeHandler : ResultHandlerCompare<C, with_id_map> {
         n_per_query.resize(nq + 1);
     }
 
-    virtual void begin(const float* norms) override {
+    void begin(const float* norms) override {
         normalizers = norms;
         for (int q = 0; q < nq; ++q) {
             thresholds[q] =
@@ -650,6 +776,8 @@ struct RangeHandler : ResultHandlerCompare<C, with_id_map> {
                     T dis = d32tab[j];
                     n_per_query[q]++;
                     triplets.push_back({idx_t(q + q0), real_idx, dis});
+
+                    this->in_range_num++;
                 }
             }
         } else {
@@ -660,6 +788,8 @@ struct RangeHandler : ResultHandlerCompare<C, with_id_map> {
                 T dis = d32tab[j];
                 n_per_query[q]++;
                 triplets.push_back({idx_t(q + q0), this->adjust_id(b, j), dis});
+
+                this->in_range_num++;
             }
         }
     }
@@ -689,11 +819,14 @@ struct RangeHandler : ResultHandlerCompare<C, with_id_map> {
 #ifndef SWIG
 
 // handler for a subset of queries
-template <class C, bool with_id_map = false>
-struct PartialRangeHandler : RangeHandler<C, with_id_map> {
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct PartialRangeHandler : RangeHandler<C, with_id_map, SL> {
     using T = typename C::T;
     using TI = typename C::TI;
-    using RHC = RangeHandler<C, with_id_map>;
+    using RHC = RangeHandler<C, with_id_map, SL>;
     using RHC::normalizers;
     using RHC::nq, RHC::q0, RHC::triplets, RHC::n_per_query;
 
@@ -706,7 +839,11 @@ struct PartialRangeHandler : RangeHandler<C, with_id_map> {
             size_t q0,
             size_t q1,
             const IDSelector* sel_in)
-            : RangeHandler<C, with_id_map>(*pres.res, radius, ntotal, sel_in),
+            : RangeHandler<C, with_id_map, SL>(
+                      *pres.res,
+                      radius,
+                      ntotal,
+                      sel_in),
               pres(pres) {
         nq = q1 - q0;
         this->q0 = q0;
@@ -748,83 +885,94 @@ struct PartialRangeHandler : RangeHandler<C, with_id_map> {
     }
 };
 
-#endif
-
-/********************************************************************************
- * Dynamic dispatching function. The consumer should have a templatized method f
- * that will be replaced with the actual SIMDResultHandler that is determined
- * dynamically.
+/** Handler that collects all matching results for a single query.
+ *
+ * Unlike HeapHandler/ReservoirHandler which maintain a top-k structure,
+ * this handler appends every result that passes the threshold to a
+ * vector of (distance, id) pairs. Useful for exhaustive collection
+ * (e.g., "return all" searches) in the fast_scan SIMD path.
  */
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
+struct SingleQueryResultCollectHandler
+        : ResultHandlerCompare<C, with_id_map, SL> {
+    using T = typename C::T;
+    using TI = typename C::TI;
+    using RHC = ResultHandlerCompare<C, with_id_map, SL>;
+    using RHC::normalizers;
+    using typename RHC::simd16uint16;
+
+    // Store as float (not T=uint16_t) since end() applies normalizer scaling
+    std::vector<std::pair<TI, float>>& collect;
+    const int q_id = 0;
 
-template <class C, bool W, class Consumer, class... Types>
-void dispatch_SIMDResultHandler_fixedCW(
-        SIMDResultHandler& res,
-        Consumer& consumer,
-        Types... args) {
-    if (auto resh_sh = dynamic_cast<SingleResultHandler<C, W>*>(&res)) {
-        consumer.template f<SingleResultHandler<C, W>>(*resh_sh, args...);
-    } else if (auto resh_hh = dynamic_cast<HeapHandler<C, W>*>(&res)) {
-        consumer.template f<HeapHandler<C, W>>(*resh_hh, args...);
-    } else if (auto resh_rh = dynamic_cast<ReservoirHandler<C, W>*>(&res)) {
-        consumer.template f<ReservoirHandler<C, W>>(*resh_rh, args...);
-    } else { // generic handler -- will not be inlined
-        FAISS_THROW_IF_NOT_FMT(
-                simd_result_handlers_accept_virtual,
-                "Running virtual handler for %s",
-                typeid(res).name());
-        consumer.template f<SIMDResultHandler>(res, args...);
+    SingleQueryResultCollectHandler(
+            std::vector<std::pair<TI, float>>& res,
+            size_t ntotal,
+            const IDSelector* sel_in)
+            : RHC(1, ntotal, sel_in), collect(res) {
+        this->q_map = &q_id;
     }
-}
 
-template <class C, class Consumer, class... Types>
-void dispatch_SIMDResultHandler_fixedC(
-        SIMDResultHandler& res,
-        Consumer& consumer,
-        Types... args) {
-    if (res.with_fields) {
-        dispatch_SIMDResultHandler_fixedCW<C, true>(res, consumer, args...);
-    } else {
-        dispatch_SIMDResultHandler_fixedCW<C, false>(res, consumer, args...);
+    void begin(const float* norms) override {
+        normalizers = norms;
     }
-}
 
-template <class Consumer, class... Types>
-void dispatch_SIMDResultHandler(
-        SIMDResultHandler& res,
-        Consumer& consumer,
-        Types... args) {
-    if (res.sizeof_ids == 0) {
-        if (auto resh = dynamic_cast<StoreResultHandler*>(&res)) {
-            consumer.template f<StoreResultHandler>(*resh, args...);
-        } else if (auto resh_2 = dynamic_cast<DummyResultHandler*>(&res)) {
-            consumer.template f<DummyResultHandler>(*resh_2, args...);
-        } else { // generic path
-            FAISS_THROW_IF_NOT_FMT(
-                    simd_result_handlers_accept_virtual,
-                    "Running virtual handler for %s",
-                    typeid(res).name());
-            consumer.template f<SIMDResultHandler>(res, args...);
-        }
-    } else if (res.sizeof_ids == sizeof(int)) {
-        if (res.is_CMax) {
-            dispatch_SIMDResultHandler_fixedC<CMax<uint16_t, int>>(
-                    res, consumer, args...);
-        } else {
-            dispatch_SIMDResultHandler_fixedC<CMin<uint16_t, int>>(
-                    res, consumer, args...);
+    void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) final {
+        if (this->disable) {
+            return;
         }
-    } else if (res.sizeof_ids == sizeof(int64_t)) {
-        if (res.is_CMax) {
-            dispatch_SIMDResultHandler_fixedC<CMax<uint16_t, int64_t>>(
-                    res, consumer, args...);
+
+        this->adjust_with_origin(q, d0, d1);
+
+        uint32_t lt_mask = this->get_lt_mask(C::neutral(), b, d0, d1);
+
+        if (!lt_mask) {
+            return;
+        }
+
+        ALIGNED(32) uint16_t d32tab[32];
+        d0.store(d32tab);
+        d1.store(d32tab + 16);
+
+        if (this->sel != nullptr) {
+            while (lt_mask) {
+                int j = __builtin_ctz(lt_mask);
+                auto real_idx = this->adjust_id(b, j);
+                lt_mask -= 1 << j;
+                if (this->sel->is_member(real_idx)) {
+                    T dis = d32tab[j];
+                    collect.emplace_back(real_idx, dis);
+                    this->in_range_num++;
+                }
+            }
         } else {
-            dispatch_SIMDResultHandler_fixedC<CMin<uint16_t, int64_t>>(
-                    res, consumer, args...);
+            while (lt_mask) {
+                int j = __builtin_ctz(lt_mask);
+                lt_mask -= 1 << j;
+                T dis = d32tab[j];
+                int64_t idx = this->adjust_id(b, j);
+                collect.emplace_back(idx, dis);
+                this->in_range_num++;
+            }
         }
-    } else {
-        FAISS_THROW_FMT("Unknown id size %d", res.sizeof_ids);
     }
-}
+
+    void end() override {
+        if (normalizers) {
+            float one_a = 1 / normalizers[0];
+            float b = normalizers[1];
+            for (size_t i = 0; i < collect.size(); i++) {
+                collect[i].second = collect[i].second * one_a + b;
+            }
+        }
+        this->scan_cnt = 0;
+    }
+};
+
+#endif
 
 } // namespace simd_result_handlers