faiss 0.6.1 → 0.6.3

data/vendor/faiss/faiss/impl/pq_code_distance/PQDistanceComputer_impl.h

@@ -20,23 +20,39 @@ namespace faiss {
 namespace pq_code_distance {
 
 template <class PQCodeDist>
-struct PQDistanceComputer : FlatCodesDistanceComputer {
+struct PQDistanceComputer final : FlatCodesDistanceComputer {
     using PQDecoder = typename PQCodeDist::PQDecoder;
-    size_t d;
     MetricType metric;
-    idx_t nb;
     const ProductQuantizer& pq;
     const float* sdc;
     std::vector<float> precomputed_table;
-    size_t ndis;
-    const float* q;
 
     float distance_to_code(const uint8_t* code) final {
-        ndis++;
-
-        float dis = PQCodeDist::distance_single_code(
+        return PQCodeDist::distance_single_code(
                 pq.M, pq.nbits, precomputed_table.data(), code);
-        return dis;
+    }
+
+    void distance_to_code_batch_4(
+            const uint8_t* c1,
+            const uint8_t* c2,
+            const uint8_t* c3,
+            const uint8_t* c4,
+            float& d1,
+            float& d2,
+            float& d3,
+            float& d4) override {
+        PQCodeDist::distance_four_codes(
+                pq.M,
+                pq.nbits,
+                precomputed_table.data(),
+                c1,
+                c2,
+                c3,
+                c4,
+                d1,
+                d2,
+                d3,
+                d4);
     }
 
     float symmetric_dis(idx_t i, idx_t j) override {
@@ -50,7 +66,6 @@ struct PQDistanceComputer : FlatCodesDistanceComputer {
             accu += sdci[codei.decode() + (codej.decode() << codei.nbits)];
             sdci += uint64_t(1) << (2 * codei.nbits);
         }
-        ndis++;
         return accu;
     }
 
@@ -58,18 +73,14 @@ struct PQDistanceComputer : FlatCodesDistanceComputer {
             : FlatCodesDistanceComputer(
                       storage.codes.data(),
                       storage.code_size),
-              pq(storage.pq),
-              q(nullptr) {
+              pq(storage.pq) {
         precomputed_table.resize(pq.M * pq.ksub);
-        nb = storage.ntotal;
-        d = storage.d;
         metric = storage.metric_type;
         if (pq.sdc_table.size() == pq.ksub * pq.ksub * pq.M) {
             sdc = pq.sdc_table.data();
         } else {
             sdc = nullptr;
         }
-        ndis = 0;
     }
 
     void set_query(const float* x) override {

data/vendor/faiss/faiss/impl/pq_code_distance/avx2.cpp

@@ -9,13 +9,15 @@
 
 #define THE_SIMD_LEVEL SIMDLevel::AVX2
 
-// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+// NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
 #include <faiss/impl/pq_code_distance/pq_code_distance-avx2.h>
-// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+// NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
 #include <faiss/utils/hamming_distance/hamming_computer-avx2.h>
-// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+// NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
+// NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
-// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+// NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>
 
 #endif // COMPILE_SIMD_AVX2

data/vendor/faiss/faiss/impl/pq_code_distance/avx512.cpp

@@ -14,6 +14,8 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/hamming_distance/hamming_computer-avx512.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>

data/vendor/faiss/faiss/impl/pq_code_distance/neon.cpp

@@ -14,6 +14,8 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/hamming_distance/hamming_computer-neon.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-generic.cpp

@@ -17,9 +17,29 @@
 
 #include <faiss/impl/pq_code_distance/pq_code_distance-generic.h>
 
+#define THE_SIMD_LEVEL SIMDLevel::NONE
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
+#undef THE_SIMD_LEVEL
+
 namespace faiss {
 namespace pq_code_distance {
 
+void pq_scan_8bit(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids,
+        bool max_heap) {
+    with_simd_level([&]<SIMDLevel SL>() {
+        pq_scan_8bit_impl<SL>(
+                M, dis_table, codes, ncodes, k, heap_dis, heap_ids, max_heap);
+    });
+}
+
 float pq_code_distance_8bit_single(
         size_t M,
         const float* sim_table,

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-inl.h

@@ -245,11 +245,47 @@ FAISS_API void pq_code_distance_8bit_four(
         float& result2,
         float& result3);
 
+/*********************************************************************
+ * Standalone PQ scan — SIMD-dispatched full-index scan.
+ *
+ * Scans all ncodes PQ codes against a precomputed distance table,
+ * maintaining a k-nearest-neighbor heap. Uses the SIMD PQ distance
+ * kernels (AVX2 gathers, etc.) for the inner loop, with the SIMD
+ * gathers inlined into the scan loop in each per-SIMD TU.
+ *
+ * Definitions are in pq_scan_impl.h (per-SIMD TUs) and
+ * pq_code_distance-generic.cpp (dispatch wrapper).
+ *********************************************************************/
+
+template <SIMDLevel SL>
+void pq_scan_8bit_impl(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids,
+        bool max_heap);
+
+/// Scan all ncodes 8-bit PQ codes, dispatching to the best SIMD level.
+/// max_heap=true for L2 (CMax), false for IP (CMin).
+FAISS_API void pq_scan_8bit(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids,
+        bool max_heap);
+
 } // namespace pq_code_distance
 
 // Re-export public API into namespace faiss for convenience
 using pq_code_distance::pq_code_distance_8bit_four;
 using pq_code_distance::pq_code_distance_8bit_single;
+using pq_code_distance::pq_scan_8bit;
 using pq_code_distance::PQCodeDistance;
 using pq_code_distance::PQCodeDistanceScalar;
 

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-sve.cpp

@@ -347,4 +347,9 @@ void pq_code_distance_8bit_four_impl<SIMDLevel::ARM_SVE>(
 } // namespace pq_code_distance
 } // namespace faiss
 
+#define THE_SIMD_LEVEL SIMDLevel::ARM_SVE
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
+#undef THE_SIMD_LEVEL
+
 #endif // COMPILE_SIMD_ARM_SVE

data/vendor/faiss/faiss/impl/pq_code_distance/pq_scan_impl.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#ifndef THE_SIMD_LEVEL
+#error "THE_SIMD_LEVEL must be defined before including pq_scan_impl.h"
+#endif
+
+#include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
+#include <faiss/utils/Heap.h>
+
+namespace faiss {
+namespace pq_code_distance {
+
+namespace {
+
+template <class C>
+void pq_scan_8bit_at_level(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids) {
+    const size_t code_size = M;
+
+    size_t j = 0;
+    for (; j + 3 < ncodes; j += 4) {
+        float d0, d1, d2, d3;
+        pq_code_distance_8bit_four_impl<THE_SIMD_LEVEL>( // NOLINT(facebook-modularize-issue-check)
+                M,
+                dis_table,
+                codes + j * code_size,
+                codes + (j + 1) * code_size,
+                codes + (j + 2) * code_size,
+                codes + (j + 3) * code_size,
+                d0,
+                d1,
+                d2,
+                d3);
+
+        if (C::cmp(heap_dis[0], d0)) {
+            heap_replace_top<C>(k, heap_dis, heap_ids, d0, j);
+        }
+        if (C::cmp(heap_dis[0], d1)) {
+            heap_replace_top<C>(k, heap_dis, heap_ids, d1, j + 1);
+        }
+        if (C::cmp(heap_dis[0], d2)) {
+            heap_replace_top<C>(k, heap_dis, heap_ids, d2, j + 2);
+        }
+        if (C::cmp(heap_dis[0], d3)) {
+            heap_replace_top<C>(k, heap_dis, heap_ids, d3, j + 3);
+        }
+    }
+
+    for (; j < ncodes; j++) {
+        float dis = pq_code_distance_8bit_single_impl<THE_SIMD_LEVEL>( // NOLINT(facebook-modularize-issue-check)
+                M, dis_table, codes + j * code_size);
+        if (C::cmp(heap_dis[0], dis)) {
+            heap_replace_top<C>(k, heap_dis, heap_ids, dis, j);
+        }
+    }
+}
+
+} // anonymous namespace
+
+template <SIMDLevel SL>
+void pq_scan_8bit_impl(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids,
+        bool max_heap);
+
+// NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization,facebook-modularize-issue-check)
+template <>
+void pq_scan_8bit_impl<THE_SIMD_LEVEL>(
+        size_t M,
+        const float* dis_table,
+        const uint8_t* codes,
+        size_t ncodes,
+        size_t k,
+        float* heap_dis,
+        int64_t* heap_ids,
+        bool max_heap) {
+    if (max_heap) {
+        pq_scan_8bit_at_level<CMax<float, int64_t>>(
+                M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
+    } else {
+        pq_scan_8bit_at_level<CMin<float, int64_t>>(
+                M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
+    }
+}
+
+} // namespace pq_code_distance
+} // namespace faiss

data/vendor/faiss/faiss/impl/pq_code_distance/rvv.cpp

@@ -56,6 +56,8 @@ void pq_code_distance_8bit_four_impl<SIMDLevel::RISCV_RVV>(
 
 #define THE_SIMD_LEVEL SIMDLevel::RISCV_RVV
 
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/pq_code_distance/pq_scan_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/hamming_distance/hamming_computer-rvv.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)

data/vendor/faiss/faiss/impl/result_handler/ResultHandler.cpp

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Generic (NONE) implementations of Top1 and Reservoir add_results, plus the
+// runtime-dispatch method bodies.  SIMD specialisations live in
+// result_handler_avx2.cpp and result_handler_avx512.cpp.
+
+#include <faiss/impl/ResultHandler.h>
+#include <faiss/impl/simd_dispatch.h>
+
+namespace faiss {
+
+// ----------------------------------------------------------------
+// SIMD-level masks
+// ----------------------------------------------------------------
+
+// Top-1: scalar fallback + AVX2 (8-wide) + AVX512 (16-wide).
+constexpr int TOP1_SIMD_LEVELS = (1 << int(SIMDLevel::NONE)) |
+        (1 << int(SIMDLevel::AVX2)) | (1 << int(SIMDLevel::AVX512));
+
+// Reservoir: scalar fallback + AVX512 compress path.
+// VPCOMPRESSPS/VPCOMPRESSD require AVX512F so there is no AVX2 path.
+// On non-AVX512 hosts the dispatch falls back to NONE automatically.
+constexpr int RESERVOIR_SIMD_LEVELS =
+        (1 << int(SIMDLevel::NONE)) | (1 << int(SIMDLevel::AVX512));
+
+// ----------------------------------------------------------------
+// Scalar (NONE) helper implementations
+// ----------------------------------------------------------------
+
+namespace {
+
+template <class C, bool use_sel>
+void top1_add_results_none(
+        Top1BlockResultHandler<C, use_sel>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab_in) {
+    using T = typename C::T;
+    using TI = typename C::TI;
+
+    for (size_t qi = self->i0; qi < self->i1; qi++) {
+        const T* dis_tab_i = dis_tab_in + (j1 - j0) * (qi - self->i0) - j0;
+
+        // Hoist best_dis / best_idx into locals so the compiler keeps them in
+        // registers across the inner loop (no aliasing with dis_tab reads).
+        T best_dis = self->dis_tab[qi];
+        TI best_idx = self->ids_tab[qi];
+
+        for (size_t j = j0; j < j1; j++) {
+            if (C::cmp(best_dis, dis_tab_i[j])) {
+                best_dis = dis_tab_i[j];
+                best_idx = (TI)j;
+            }
+        }
+
+        self->dis_tab[qi] = best_dis;
+        self->ids_tab[qi] = best_idx;
+    }
+}
+
+template <class C, bool use_sel>
+void reservoir_add_results_none(
+        ReservoirBlockResultHandler<C, use_sel>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_in) {
+    using T = typename C::T;
+    using TI = typename C::TI;
+
+#pragma omp parallel for
+    for (int64_t qi = (int64_t)self->i0; qi < (int64_t)self->i1; qi++) {
+        ReservoirTopN<C>& res = self->reservoirs[qi - (int64_t)self->i0];
+        const T* dis_tab_i = dis_in + (j1 - j0) * (qi - (int64_t)self->i0) - j0;
+
+        // Hoist res.i and res.threshold into locals so the compiler keeps
+        // them in registers.
+        size_t ri = res.i;
+        T thresh = res.threshold;
+
+        for (size_t j = j0; j < j1; j++) {
+            T dis = dis_tab_i[j];
+            if (C::cmp(thresh, dis)) {
+                res.vals[ri] = dis;
+                res.ids[ri] = (TI)j;
+                ri++;
+                if (ri >= res.capacity) {
+                    res.i = ri;
+                    res.shrink_fuzzy();
+                    ri = res.i;
+                    thresh = res.threshold;
+                }
+            }
+        }
+        res.i = ri;
+    }
+}
+
+} // namespace
+
+// ----------------------------------------------------------------
+// SIMDLevel::NONE explicit specialisations
+// ----------------------------------------------------------------
+
+// Instantiate top1_add_results_tpl<C, use_sel, SIMDLevel::NONE> and
+// reservoir_add_results_tpl<C, use_sel, SIMDLevel::NONE> for all
+// (C, use_sel) combinations that the rest of FAISS uses.
+#define INSTANTIATE_NONE(C, use_sel)                                  \
+    template <>                                                       \
+    void top1_add_results_tpl<C, use_sel, SIMDLevel::NONE>(           \
+            Top1BlockResultHandler<C, use_sel> * self,                \
+            size_t j0,                                                \
+            size_t j1,                                                \
+            const float* dis_tab) {                                   \
+        top1_add_results_none<C, use_sel>(self, j0, j1, dis_tab);     \
+    }                                                                 \
+    template <>                                                       \
+    void reservoir_add_results_tpl<C, use_sel, SIMDLevel::NONE>(      \
+            ReservoirBlockResultHandler<C, use_sel> * self,           \
+            size_t j0,                                                \
+            size_t j1,                                                \
+            const float* dis_in) {                                    \
+        reservoir_add_results_none<C, use_sel>(self, j0, j1, dis_in); \
+    }
+
+// Type aliases so the comma in CMax<float, int64_t> doesn't split macro args.
+using CMaxFI = CMax<float, int64_t>;
+using CMinFI = CMin<float, int64_t>;
+
+INSTANTIATE_NONE(CMaxFI, false)
+INSTANTIATE_NONE(CMaxFI, true)
+INSTANTIATE_NONE(CMinFI, false)
+INSTANTIATE_NONE(CMinFI, true)
+
+#undef INSTANTIATE_NONE
+
+// ----------------------------------------------------------------
+// add_results method definitions — dispatch to the right SL kernel
+// ----------------------------------------------------------------
+
+template <class C, bool use_sel>
+void Top1BlockResultHandler<C, use_sel>::add_results(
+        size_t j0,
+        size_t j1,
+        const T* dis_tab_2) {
+    with_selected_simd_levels<TOP1_SIMD_LEVELS>([&]<SIMDLevel SL>() {
+        top1_add_results_tpl<C, use_sel, SL>(this, j0, j1, dis_tab_2);
+    });
+}
+
+template <class C, bool use_sel>
+void ReservoirBlockResultHandler<C, use_sel>::add_results(
+        size_t j0,
+        size_t j1,
+        const T* dis_in) {
+    with_selected_simd_levels<RESERVOIR_SIMD_LEVELS>([&]<SIMDLevel SL>() {
+        reservoir_add_results_tpl<C, use_sel, SL>(this, j0, j1, dis_in);
+    });
+}
+
+// ----------------------------------------------------------------
+// Explicit class-template instantiations (force linkage)
+// ----------------------------------------------------------------
+
+template void Top1BlockResultHandler<CMax<float, int64_t>, false>::add_results(
+        size_t,
+        size_t,
+        const float*);
+template void Top1BlockResultHandler<CMax<float, int64_t>, true>::add_results(
+        size_t,
+        size_t,
+        const float*);
+template void Top1BlockResultHandler<CMin<float, int64_t>, false>::add_results(
+        size_t,
+        size_t,
+        const float*);
+template void Top1BlockResultHandler<CMin<float, int64_t>, true>::add_results(
+        size_t,
+        size_t,
+        const float*);
+
+template void ReservoirBlockResultHandler<CMax<float, int64_t>, false>::
+        add_results(size_t, size_t, const float*);
+template void ReservoirBlockResultHandler<CMax<float, int64_t>, true>::
+        add_results(size_t, size_t, const float*);
+template void ReservoirBlockResultHandler<CMin<float, int64_t>, false>::
+        add_results(size_t, size_t, const float*);
+template void ReservoirBlockResultHandler<CMin<float, int64_t>, true>::
+        add_results(size_t, size_t, const float*);
+
+} // namespace faiss

data/vendor/faiss/faiss/impl/result_handler/avx2.cpp

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// AVX2 specialisation of Top1 add_results (8-wide branchless argmin/argmax).
+// Reservoir stays on the NONE path — VPCOMPRESSPS requires AVX512F.
+
+#ifdef COMPILE_SIMD_AVX2
+
+#include <faiss/impl/ResultHandler.h>
+
+#include <immintrin.h>
+#include <type_traits>
+
+namespace faiss {
+
+namespace {
+
+/// Templated AVX2 implementation of Top1 add_results for both CMax (keeps the
+/// smallest distance) and CMin (keeps the largest similarity).
+template <class C, bool use_sel>
+void top1_add_results_avx2(
+        Top1BlockResultHandler<C, use_sel>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab_in) {
+    static_assert(
+            std::is_same<typename C::T, float>::value,
+            "This code expects float distances");
+    using TI = typename C::TI;
+    const __m256i vstep = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
+
+    for (size_t qi = self->i0; qi < self->i1; qi++) {
+        const float* dis_tab_i = dis_tab_in + (j1 - j0) * (qi - self->i0) - j0;
+
+        // Hoist best_dis / best_idx into locals so the compiler keeps them in
+        // registers across the inner loop (no aliasing with dis_tab reads).
+        float best_dis = self->dis_tab[qi];
+        TI best_idx = self->ids_tab[qi];
+        size_t j = j0;
+
+        __m256 vbest = _mm256_set1_ps(best_dis);
+        __m256i vbest_idx = _mm256_set1_epi32((int32_t)best_idx);
+
+        for (; j + 8 <= j1; j += 8) {
+            __m256 vdis = _mm256_loadu_ps(dis_tab_i + j);
+            __m256i vidx =
+                    _mm256_add_epi32(_mm256_set1_epi32((int32_t)j), vstep);
+
+            // CMax (L2 nearest neighbour): keep lane if dis < best.
+            // CMin (inner product):        keep lane if dis > best.
+            __m256 mask;
+            if constexpr (C::is_max) {
+                mask = _mm256_cmp_ps(vdis, vbest, _CMP_LT_OS);
+            } else {
+                mask = _mm256_cmp_ps(vdis, vbest, _CMP_GT_OS);
+            }
+            vbest = _mm256_blendv_ps(vbest, vdis, mask);
+            vbest_idx = _mm256_blendv_epi8(
+                    vbest_idx, vidx, _mm256_castps_si256(mask));
+        }
+
+        // Horizontal reduction across 8 lanes.
+        alignas(32) float best_arr[8];
+        alignas(32) int32_t idx_arr[8];
+        _mm256_store_ps(best_arr, vbest);
+        _mm256_store_si256((__m256i*)idx_arr, vbest_idx);
+        for (int k = 0; k < 8; k++) {
+            if (C::cmp(best_dis, best_arr[k])) {
+                best_dis = best_arr[k];
+                best_idx = (TI)idx_arr[k];
+            }
+        }
+
+        // Scalar tail.
+        for (; j < j1; j++) {
+            if (C::cmp(best_dis, dis_tab_i[j])) {
+                best_dis = dis_tab_i[j];
+                best_idx = (TI)j;
+            }
+        }
+
+        self->dis_tab[qi] = best_dis;
+        self->ids_tab[qi] = best_idx;
+    }
+}
+
+} // namespace
+
+// Explicit specialisations for AVX2
+
+template <>
+void top1_add_results_tpl<CMax<float, int64_t>, false, SIMDLevel::AVX2>(
+        Top1BlockResultHandler<CMax<float, int64_t>, false>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab) {
+    top1_add_results_avx2<CMax<float, int64_t>, false>(self, j0, j1, dis_tab);
+}
+
+template <>
+void top1_add_results_tpl<CMax<float, int64_t>, true, SIMDLevel::AVX2>(
+        Top1BlockResultHandler<CMax<float, int64_t>, true>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab) {
+    top1_add_results_avx2<CMax<float, int64_t>, true>(self, j0, j1, dis_tab);
+}
+
+template <>
+void top1_add_results_tpl<CMin<float, int64_t>, false, SIMDLevel::AVX2>(
+        Top1BlockResultHandler<CMin<float, int64_t>, false>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab) {
+    top1_add_results_avx2<CMin<float, int64_t>, false>(self, j0, j1, dis_tab);
+}
+
+template <>
+void top1_add_results_tpl<CMin<float, int64_t>, true, SIMDLevel::AVX2>(
+        Top1BlockResultHandler<CMin<float, int64_t>, true>* self,
+        size_t j0,
+        size_t j1,
+        const float* dis_tab) {
+    top1_add_results_avx2<CMin<float, int64_t>, true>(self, j0, j1, dis_tab);
+}
+
+} // namespace faiss
+
+#endif // COMPILE_SIMD_AVX2