faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/utils/simd_impl/distances_avx2.cpp

@@ -9,24 +9,56 @@
 
 #include <immintrin.h>
 
-#define AUTOVEC_LEVEL SIMDLevel::AVX2
+#include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/ResultHandler.h>
+#include <faiss/utils/distances_fused/distances_fused.h>
+#include <faiss/utils/simd_impl/exhaustive_L2sqr_blas_cmax.h>
+
+#ifndef FINTEGER
+#define FINTEGER long
+#endif
+
+extern "C" {
+
+int sgemm_(
+        const char* transa,
+        const char* transb,
+        FINTEGER* m,
+        FINTEGER* n,
+        FINTEGER* k,
+        const float* alpha,
+        const float* a,
+        FINTEGER* lda,
+        const float* b,
+        FINTEGER* ldb,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
+}
+
+#define THE_SIMD_LEVEL SIMDLevel::AVX2
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/simd_impl/distances_autovec-inl.h>
 
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/distances_simdlib256.h>
+
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/simd_impl/distances_sse-inl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/transpose/transpose-avx2-inl.h>
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/IVFFlatScanner-inl.h>
 
 namespace faiss {
 
 template <>
 void fvec_madd<SIMDLevel::AVX2>(
         const size_t n,
-        const float* __restrict a,
+        const float* a,
         const float bf,
-        const float* __restrict b,
-        float* __restrict c) {
+        const float* b,
+        float* c) {
     //
     const size_t n8 = n / 8;
     const size_t n_for_masking = n % 8;
@@ -1182,4 +1214,218 @@ int fvec_madd_and_argmin<SIMDLevel::AVX2>(
     return fvec_madd_and_argmin_sse(n, a, bf, b, c);
 }
 
+template <>
+void exhaustive_L2sqr_blas_cmax<SIMDLevel::AVX2>(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        Top1BlockResultHandler<CMax<float, int64_t>>& res,
+        const float* y_norms) {
+    // BLAS does not like empty matrices
+    if (nx == 0 || ny == 0) {
+        return;
+    }
+
+    /* block sizes */
+    const size_t bs_x = distance_compute_blas_query_bs;
+    const size_t bs_y = distance_compute_blas_database_bs;
+    // const size_t bs_x = 16, bs_y = 16;
+    std::unique_ptr<float[]> ip_block(new float[bs_x * bs_y]);
+    std::unique_ptr<float[]> x_norms(new float[nx]);
+    std::unique_ptr<float[]> del2;
+
+    fvec_norms_L2sqr(x_norms.get(), x, d, nx);
+
+    if (!y_norms) {
+        float* y_norms2 = new float[ny];
+        del2.reset(y_norms2);
+        fvec_norms_L2sqr(y_norms2, y, d, ny);
+        y_norms = y_norms2;
+    }
+
+    for (size_t i0 = 0; i0 < nx; i0 += bs_x) {
+        size_t i1 = i0 + bs_x;
+        if (i1 > nx) {
+            i1 = nx;
+        }
+
+        res.begin_multiple(i0, i1);
+
+        for (size_t j0 = 0; j0 < ny; j0 += bs_y) {
+            size_t j1 = j0 + bs_y;
+            if (j1 > ny) {
+                j1 = ny;
+            }
+            /* compute the actual dot products */
+            {
+                float one = 1, zero = 0;
+                FINTEGER nyi = j1 - j0, nxi = i1 - i0, di = d;
+                sgemm_("Transpose",
+                       "Not transpose",
+                       &nyi,
+                       &nxi,
+                       &di,
+                       &one,
+                       y + j0 * d,
+                       &di,
+                       x + i0 * d,
+                       &di,
+                       &zero,
+                       ip_block.get(),
+                       &nyi);
+            }
+#pragma omp parallel for schedule(static) if ((i1 - i0) >= 16)
+            for (int64_t i = static_cast<int64_t>(i0);
+                 i < static_cast<int64_t>(i1);
+                 i++) {
+                float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
+
+                _mm_prefetch((const char*)ip_line, _MM_HINT_NTA);
+                _mm_prefetch((const char*)(ip_line + 16), _MM_HINT_NTA);
+
+                // constant
+                const __m256 mul_minus2 = _mm256_set1_ps(-2);
+
+                // Track 8 min distances + 8 min indices.
+                // All the distances tracked do not take x_norms[i]
+                //   into account in order to get rid of extra
+                //   _mm256_add_ps(x_norms[i], ...) instructions
+                //   is distance computations.
+                __m256 min_distances =
+                        _mm256_set1_ps(res.dis_tab[i] - x_norms[i]);
+
+                // these indices are local and are relative to j0.
+                // so, value 0 means j0.
+                __m256i min_indices = _mm256_set1_epi32(0);
+
+                __m256i current_indices =
+                        _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
+                const __m256i indices_delta = _mm256_set1_epi32(8);
+
+                // current j index
+                size_t idx_j = 0;
+                size_t count = j1 - j0;
+
+                // process 16 elements per loop
+                for (; idx_j < (count / 16) * 16; idx_j += 16, ip_line += 16) {
+                    _mm_prefetch((const char*)(ip_line + 32), _MM_HINT_NTA);
+                    _mm_prefetch((const char*)(ip_line + 48), _MM_HINT_NTA);
+
+                    // load values for norms
+                    const __m256 y_norm_0 =
+                            _mm256_loadu_ps(y_norms + idx_j + j0 + 0);
+                    const __m256 y_norm_1 =
+                            _mm256_loadu_ps(y_norms + idx_j + j0 + 8);
+
+                    // load values for dot products
+                    const __m256 ip_0 = _mm256_loadu_ps(ip_line + 0);
+                    const __m256 ip_1 = _mm256_loadu_ps(ip_line + 8);
+
+                    // compute dis = y_norm[j] - 2 * dot(x_norm[i], y_norm[j]).
+                    // x_norm[i] was dropped off because it is a constant for a
+                    // given i. We'll deal with it later.
+                    __m256 distances_0 =
+                            _mm256_fmadd_ps(ip_0, mul_minus2, y_norm_0);
+                    __m256 distances_1 =
+                            _mm256_fmadd_ps(ip_1, mul_minus2, y_norm_1);
+
+                    // compare the new distances to the min distances
+                    // for each of the first group of 8 AVX2 components.
+                    const __m256 comparison_0 = _mm256_cmp_ps(
+                            min_distances, distances_0, _CMP_LE_OS);
+
+                    // update min distances and indices with closest vectors if
+                    // needed.
+                    min_distances = _mm256_blendv_ps(
+                            distances_0, min_distances, comparison_0);
+                    min_indices = _mm256_castps_si256(_mm256_blendv_ps(
+                            _mm256_castsi256_ps(current_indices),
+                            _mm256_castsi256_ps(min_indices),
+                            comparison_0));
+                    current_indices =
+                            _mm256_add_epi32(current_indices, indices_delta);
+
+                    // compare the new distances to the min distances
+                    // for each of the second group of 8 AVX2 components.
+                    const __m256 comparison_1 = _mm256_cmp_ps(
+                            min_distances, distances_1, _CMP_LE_OS);
+
+                    // update min distances and indices with closest vectors if
+                    // needed.
+                    min_distances = _mm256_blendv_ps(
+                            distances_1, min_distances, comparison_1);
+                    min_indices = _mm256_castps_si256(_mm256_blendv_ps(
+                            _mm256_castsi256_ps(current_indices),
+                            _mm256_castsi256_ps(min_indices),
+                            comparison_1));
+                    current_indices =
+                            _mm256_add_epi32(current_indices, indices_delta);
+                }
+
+                // dump values and find the minimum distance / minimum index
+                float min_distances_scalar[8];
+                uint32_t min_indices_scalar[8];
+                _mm256_storeu_ps(min_distances_scalar, min_distances);
+                _mm256_storeu_si256(
+                        (__m256i*)(min_indices_scalar), min_indices);
+
+                float current_min_distance = res.dis_tab[i];
+                uint32_t current_min_index = res.ids_tab[i];
+
+                // This unusual comparison is needed to maintain the behavior
+                // of the original implementation: if two indices are
+                // represented with equal distance values, then
+                // the index with the min value is returned.
+                for (size_t jv = 0; jv < 8; jv++) {
+                    // add missing x_norms[i]
+                    float distance_candidate =
+                            min_distances_scalar[jv] + x_norms[i];
+
+                    // negative values can occur for identical vectors
+                    //    due to roundoff errors.
+                    if (distance_candidate < 0) {
+                        distance_candidate = 0;
+                    }
+
+                    int64_t index_candidate = min_indices_scalar[jv] + j0;
+
+                    if (current_min_distance > distance_candidate) {
+                        current_min_distance = distance_candidate;
+                        current_min_index = index_candidate;
+                    } else if (
+                            current_min_distance == distance_candidate &&
+                            current_min_index > index_candidate) {
+                        current_min_index = index_candidate;
+                    }
+                }
+
+                // process leftovers
+                for (; idx_j < count; idx_j++, ip_line++) {
+                    float ip = *ip_line;
+                    float dis = x_norms[i] + y_norms[idx_j + j0] - 2 * ip;
+                    // negative values can occur for identical vectors
+                    //    due to roundoff errors.
+                    if (dis < 0) {
+                        dis = 0;
+                    }
+
+                    if (current_min_distance > dis) {
+                        current_min_distance = dis;
+                        current_min_index = idx_j + j0;
+                    }
+                }
+
+                //
+                res.add_result(i, current_min_distance, current_min_index);
+            }
+        }
+        // Does nothing for SingleBestResultHandler, but
+        // keeping the call for the consistency.
+        res.end_multiple();
+        InterruptCallback::check();
+    }
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/utils/simd_impl/distances_avx512.cpp

@@ -9,8 +9,11 @@
 
 #include <immintrin.h>
 
-#define AUTOVEC_LEVEL SIMDLevel::AVX512
+#define THE_SIMD_LEVEL SIMDLevel::AVX512
 #include <faiss/utils/simd_impl/distances_autovec-inl.h>
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/IVFFlatScanner-inl.h>
+
 #include <faiss/utils/simd_impl/distances_sse-inl.h>
 #include <faiss/utils/transpose/transpose-avx512-inl.h>
 
@@ -19,10 +22,10 @@ namespace faiss {
 template <>
 void fvec_madd<SIMDLevel::AVX512>(
         const size_t n,
-        const float* __restrict a,
+        const float* a,
         const float bf,
-        const float* __restrict b,
-        float* __restrict c) {
+        const float* b,
+        float* c) {
     const size_t n16 = n / 16;
     const size_t n_for_masking = n % 16;
 

data/vendor/faiss/faiss/utils/simd_impl/distances_rvv.cpp

@@ -0,0 +1,189 @@
+/*
+ * 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.
+ */
+
+// -*- c++ -*-
+
+#include <faiss/utils/distances.h>
+
+#ifdef COMPILE_SIMD_RISCV_RVV
+
+#include <faiss/utils/extra_distances.h>
+
+namespace faiss {
+
+template <>
+float fvec_norm_L2sqr<SIMDLevel::RISCV_RVV>(const float* x, size_t d) {
+    return fvec_norm_L2sqr<SIMDLevel::NONE>(x, d);
+}
+
+template <>
+float fvec_L2sqr<SIMDLevel::RISCV_RVV>(
+        const float* x,
+        const float* y,
+        size_t d) {
+    return fvec_L2sqr<SIMDLevel::NONE>(x, y, d);
+}
+
+template <>
+float fvec_inner_product<SIMDLevel::RISCV_RVV>(
+        const float* x,
+        const float* y,
+        size_t d) {
+    return fvec_inner_product<SIMDLevel::NONE>(x, y, d);
+}
+
+template <>
+float fvec_L1<SIMDLevel::RISCV_RVV>(const float* x, const float* y, size_t d) {
+    return fvec_L1<SIMDLevel::NONE>(x, y, d);
+}
+
+template <>
+float fvec_Linf<SIMDLevel::RISCV_RVV>(
+        const float* x,
+        const float* y,
+        size_t d) {
+    return fvec_Linf<SIMDLevel::NONE>(x, y, d);
+}
+
+template <>
+void fvec_inner_product_batch_4<SIMDLevel::RISCV_RVV>(
+        const float* x,
+        const float* y0,
+        const float* y1,
+        const float* y2,
+        const float* y3,
+        const size_t d,
+        float& dis0,
+        float& dis1,
+        float& dis2,
+        float& dis3) {
+    fvec_inner_product_batch_4<SIMDLevel::NONE>(
+            x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3);
+}
+
+template <>
+void fvec_L2sqr_batch_4<SIMDLevel::RISCV_RVV>(
+        const float* x,
+        const float* y0,
+        const float* y1,
+        const float* y2,
+        const float* y3,
+        const size_t d,
+        float& dis0,
+        float& dis1,
+        float& dis2,
+        float& dis3) {
+    fvec_L2sqr_batch_4<SIMDLevel::NONE>(
+            x, y0, y1, y2, y3, d, dis0, dis1, dis2, dis3);
+}
+
+template <>
+void fvec_L2sqr_ny_transposed<SIMDLevel::RISCV_RVV>(
+        float* dis,
+        const float* x,
+        const float* y,
+        const float* y_sqlen,
+        size_t d,
+        size_t d_offset,
+        size_t ny) {
+    fvec_L2sqr_ny_transposed<SIMDLevel::NONE>(
+            dis, x, y, y_sqlen, d, d_offset, ny);
+}
+
+template <>
+void fvec_inner_products_ny<SIMDLevel::RISCV_RVV>(
+        float* ip,
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t ny) {
+    fvec_inner_products_ny<SIMDLevel::NONE>(ip, x, y, d, ny);
+}
+
+template <>
+void fvec_L2sqr_ny<SIMDLevel::RISCV_RVV>(
+        float* dis,
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t ny) {
+    fvec_L2sqr_ny<SIMDLevel::NONE>(dis, x, y, d, ny);
+}
+
+template <>
+size_t fvec_L2sqr_ny_nearest<SIMDLevel::RISCV_RVV>(
+        float* distances_tmp_buffer,
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t ny) {
+    return fvec_L2sqr_ny_nearest<SIMDLevel::NONE>(
+            distances_tmp_buffer, x, y, d, ny);
+}
+
+template <>
+size_t fvec_L2sqr_ny_nearest_y_transposed<SIMDLevel::RISCV_RVV>(
+        float* distances_tmp_buffer,
+        const float* x,
+        const float* y,
+        const float* y_sqlen,
+        size_t d,
+        size_t d_offset,
+        size_t ny) {
+    return fvec_L2sqr_ny_nearest_y_transposed<SIMDLevel::NONE>(
+            distances_tmp_buffer, x, y, y_sqlen, d, d_offset, ny);
+}
+
+template <>
+void fvec_madd<SIMDLevel::RISCV_RVV>(
+        size_t n,
+        const float* a,
+        float bf,
+        const float* b,
+        float* c) {
+    fvec_madd<SIMDLevel::NONE>(n, a, bf, b, c);
+}
+
+template <>
+int fvec_madd_and_argmin<SIMDLevel::RISCV_RVV>(
+        size_t n,
+        const float* a,
+        float bf,
+        const float* b,
+        float* c) {
+    return fvec_madd_and_argmin<SIMDLevel::NONE>(n, a, bf, b, c);
+}
+
+#define DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(metric)                 \
+    template <>                                                     \
+    float VectorDistance<metric, SIMDLevel::RISCV_RVV>::operator()( \
+            const float* x, const float* y) const {                 \
+        return VectorDistance<metric, SIMDLevel::NONE>(             \
+                this->d, this->metric_arg)(x, y);                   \
+    }
+
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_L2)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_INNER_PRODUCT)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_L1)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_Linf)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_Lp)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_Canberra)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_BrayCurtis)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_JensenShannon)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_Jaccard)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_NaNEuclidean)
+DEFINE_VECTOR_DISTANCE_RVV_FALLBACK(METRIC_GOWER)
+
+#undef DEFINE_VECTOR_DISTANCE_RVV_FALLBACK
+
+} // namespace faiss
+
+#define THE_SIMD_LEVEL SIMDLevel::RISCV_RVV
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/IVFFlatScanner-inl.h>
+
+#endif // COMPILE_SIMD_RISCV_RVV

data/vendor/faiss/faiss/utils/simd_impl/distances_simdlib256.h

@@ -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.
+ */
+
+#pragma once
+
+#include <algorithm>
+
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/platform_macros.h>
+#include <faiss/impl/simdlib/simdlib_dispatch.h>
+#include <faiss/utils/distances.h>
+
+namespace faiss {
+
+template <>
+void fvec_sub<THE_SIMD_LEVEL>(
+        size_t d,
+        const float* a,
+        const float* b,
+        float* c) {
+    size_t i;
+    for (i = 0; i + 7 < d; i += 8) {
+        simd8float32_tpl<THE_SIMD_LEVEL> ci, ai, bi;
+        ai.loadu(a + i);
+        bi.loadu(b + i);
+        ci = ai - bi;
+        ci.storeu(c + i);
+    }
+    for (; i < d; i++) {
+        c[i] = a[i] - b[i];
+    }
+}
+
+template <>
+void fvec_add<THE_SIMD_LEVEL>(
+        size_t d,
+        const float* a,
+        const float* b,
+        float* c) {
+    size_t i;
+    for (i = 0; i + 7 < d; i += 8) {
+        simd8float32_tpl<THE_SIMD_LEVEL> ci, ai, bi;
+        ai.loadu(a + i);
+        bi.loadu(b + i);
+        ci = ai + bi;
+        ci.storeu(c + i);
+    }
+    for (; i < d; i++) {
+        c[i] = a[i] + b[i];
+    }
+}
+
+template <>
+void fvec_add<THE_SIMD_LEVEL>(size_t d, const float* a, float b, float* c) {
+    size_t i;
+    simd8float32_tpl<THE_SIMD_LEVEL> bv(b);
+    for (i = 0; i + 7 < d; i += 8) {
+        simd8float32_tpl<THE_SIMD_LEVEL> ci, ai;
+        ai.loadu(a + i);
+        ci = ai + bv;
+        ci.storeu(c + i);
+    }
+    for (; i < d; i++) {
+        c[i] = a[i] + b;
+    }
+}
+
+/***************************************************************************
+ * PQ tables computations
+ ***************************************************************************/
+
+namespace {
+
+/// compute the IP for dsub = 2 for 8 centroids and 4 sub-vectors at a time
+template <SIMDLevel SL, bool is_inner_product>
+void pq2_8cents_table(
+        const simd8float32_tpl<SL> centroids[8],
+        const simd8float32_tpl<SL> x,
+        float* out,
+        size_t ldo,
+        size_t nout = 4) {
+    simd8float32_tpl<SL> ips[4];
+
+    for (int i = 0; i < 4; i++) {
+        simd8float32_tpl<SL> p1, p2;
+        if (is_inner_product) {
+            p1 = x * centroids[2 * i];
+            p2 = x * centroids[2 * i + 1];
+        } else {
+            p1 = (x - centroids[2 * i]);
+            p1 = p1 * p1;
+            p2 = (x - centroids[2 * i + 1]);
+            p2 = p2 * p2;
+        }
+        ips[i] = hadd(p1, p2);
+    }
+
+    simd8float32_tpl<SL> ip02a = geteven(ips[0], ips[1]);
+    simd8float32_tpl<SL> ip02b = geteven(ips[2], ips[3]);
+    simd8float32_tpl<SL> ip0 = getlow128(ip02a, ip02b);
+    simd8float32_tpl<SL> ip2 = gethigh128(ip02a, ip02b);
+
+    simd8float32_tpl<SL> ip13a = getodd(ips[0], ips[1]);
+    simd8float32_tpl<SL> ip13b = getodd(ips[2], ips[3]);
+    simd8float32_tpl<SL> ip1 = getlow128(ip13a, ip13b);
+    simd8float32_tpl<SL> ip3 = gethigh128(ip13a, ip13b);
+
+    switch (nout) {
+        case 4:
+            ip3.storeu(out + 3 * ldo);
+            [[fallthrough]];
+        case 3:
+            ip2.storeu(out + 2 * ldo);
+            [[fallthrough]];
+        case 2:
+            ip1.storeu(out + 1 * ldo);
+            [[fallthrough]];
+        case 1:
+            ip0.storeu(out);
+    }
+}
+
+template <SIMDLevel SL>
+simd8float32_tpl<SL> load_simd8float32_partial(const float* x, int n) {
+    ALIGNED(32) float tmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+    float* wp = tmp;
+    for (int i = 0; i < n; i++) {
+        *wp++ = *x++;
+    }
+    return simd8float32_tpl<SL>(tmp);
+}
+
+} // anonymous namespace
+
+template <>
+void compute_PQ_dis_tables_dsub2<THE_SIMD_LEVEL>(
+        size_t d,
+        size_t ksub,
+        const float* all_centroids,
+        size_t nx,
+        const float* x,
+        bool is_inner_product,
+        float* dis_tables) {
+    size_t M = d / 2;
+    FAISS_THROW_IF_NOT(ksub % 8 == 0);
+
+    for (size_t m0 = 0; m0 < M; m0 += 4) {
+        int m1 = std::min(M, m0 + 4);
+        for (int k0 = 0; k0 < ksub; k0 += 8) {
+            simd8float32_tpl<THE_SIMD_LEVEL> centroids[8];
+            for (int k = 0; k < 8; k++) {
+                ALIGNED(32) float centroid[8];
+                size_t wp = 0;
+                size_t rp = (m0 * ksub + k + k0) * 2;
+                for (int m = m0; m < m1; m++) {
+                    centroid[wp++] = all_centroids[rp];
+                    centroid[wp++] = all_centroids[rp + 1];
+                    rp += 2 * ksub;
+                }
+                centroids[k] = simd8float32_tpl<THE_SIMD_LEVEL>(centroid);
+            }
+            for (size_t i = 0; i < nx; i++) {
+                simd8float32_tpl<THE_SIMD_LEVEL> xi;
+                if (m1 == m0 + 4) {
+                    xi.loadu(x + i * d + m0 * 2);
+                } else {
+                    xi = load_simd8float32_partial<THE_SIMD_LEVEL>(
+                            x + i * d + m0 * 2, 2 * (m1 - m0));
+                }
+
+                if (is_inner_product) {
+                    pq2_8cents_table<THE_SIMD_LEVEL, true>(
+                            centroids,
+                            xi,
+                            dis_tables + (i * M + m0) * ksub + k0,
+                            ksub,
+                            m1 - m0);
+                } else {
+                    pq2_8cents_table<THE_SIMD_LEVEL, false>(
+                            centroids,
+                            xi,
+                            dis_tables + (i * M + m0) * ksub + k0,
+                            ksub,
+                            m1 - m0);
+                }
+            }
+        }
+    }
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/utils/simd_impl/distances_sse-inl.h

@@ -360,7 +360,8 @@ inline int fvec_madd_and_argmin_sse(
         float bf,
         const float* b,
         float* c) {
-    if ((n & 3) == 0 && ((((long)a) | ((long)b) | ((long)c)) & 15) == 0) {
+    if ((n & 3) == 0 &&
+        ((((uintptr_t)a) | ((uintptr_t)b) | ((uintptr_t)c)) & 15) == 0) {
         return fvec_madd_and_argmin_sse_ref(n, a, bf, b, c);
     } else {
         return fvec_madd_and_argmin<SIMDLevel::NONE>(n, a, bf, b, c);