faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/utils/partitioning.h

@@ -11,6 +11,8 @@
 #include <stdio.h>
 
 #include <faiss/impl/platform_macros.h>
+#include <faiss/utils/ordered_key_value.h>
+#include <faiss/utils/simd_levels.h>
 
 namespace faiss {
 
@@ -58,6 +60,35 @@ void simd_histogram_16(
         int shift,
         int* hist);
 
+/** SIMD-dispatched partition for aligned uint16_t arrays.
+ *  Specializations live in per-ISA TUs (partitioning_avx2.cpp, etc.). */
+template <SIMDLevel SL, class C>
+typename C::T partition_fuzzy_simd(
+        uint16_t* vals,
+        typename C::TI* ids,
+        size_t n,
+        size_t q_min,
+        size_t q_max,
+        size_t* q_out);
+
+/** SIMD-dispatched histogram functions.
+ *  Specializations live in per-ISA TUs. */
+template <SIMDLevel SL>
+void simd_histogram_8(
+        const uint16_t* data,
+        int n,
+        uint16_t min,
+        int shift,
+        int* hist);
+
+template <SIMDLevel SL>
+void simd_histogram_16(
+        const uint16_t* data,
+        int n,
+        uint16_t min,
+        int shift,
+        int* hist);
+
 struct PartitionStats {
     uint64_t bisect_cycles;
     uint64_t compress_cycles;

data/vendor/faiss/faiss/utils/popcount.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <cstdint>
+
+// popcount = count number of 1s in the binary representation of a number
+
+#ifdef _MSC_VER
+#include <intrin.h>
+inline int popcount32(uint32_t x) {
+    return __popcnt(x);
+}
+inline int popcount64(uint64_t x) {
+    return static_cast<int>(__popcnt64(x));
+}
+#else
+inline int popcount32(uint32_t x) {
+    return __builtin_popcount(x);
+}
+inline int popcount64(uint64_t x) {
+    return __builtin_popcountll(x);
+}
+#endif

data/vendor/faiss/faiss/utils/pq_code_distance.h

@@ -29,7 +29,7 @@ namespace pq_code_distance {
  *
  * PQCodeDistance<PQDecoderT, SL> computes PQ code distances at a given
  * SIMD level. The dispatch site (IndexIVFPQ.cpp, IndexPQ.cpp) uses
- * DISPATCH_SIMDLevel to select SL at runtime, which instantiates
+ * with_simd_level to select SL at runtime, which instantiates
  * PQCodeDistance for ALL decoder types (PQDecoder8, PQDecoder16,
  * PQDecoderGeneric) at the chosen level.
  *
@@ -211,7 +211,7 @@ struct PQCodeDistance {
  * Non-templated PQ code distance dispatch (PQDecoder8 only).
  *
  * These follow the same pattern as distances.h: the caller does not
- * name a SIMDLevel. Internally they dispatch via DISPATCH_SIMDLevel
+ * name a SIMDLevel. Internally they dispatch via with_simd_level
  * to the best available SIMD implementation (DD: runtime detection,
  * static: compile-time selection). Definitions are in
  * pq_code_distance-generic.cpp.

data/vendor/faiss/faiss/utils/prefetch.h

@@ -9,9 +9,9 @@
 
 // prefetches
 
-#ifdef __AVX__
+#if defined(__x86_64__) || defined(_M_X64)
 
-// AVX
+// x86_64
 
 #include <xmmintrin.h>
 

data/vendor/faiss/faiss/utils/quantize_lut.cpp

@@ -27,7 +27,7 @@ namespace {
 // there can be NaNs in tables, they should be ignored
 float tab_min(const float* tab, size_t n) {
     float min = HUGE_VAL;
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         if (tab[i] < min) {
             min = tab[i];
         }
@@ -37,7 +37,7 @@ float tab_min(const float* tab, size_t n) {
 
 float tab_max(const float* tab, size_t n) {
     float max = -HUGE_VAL;
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         if (tab[i] > max) {
             max = tab[i];
         }
@@ -46,14 +46,14 @@ float tab_max(const float* tab, size_t n) {
 }
 
 void round_tab(float* tab, size_t n, float a, float bi) {
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         tab[i] = floorf((tab[i] - bi) * a + 0.5);
     }
 }
 
 template <typename T>
 void round_tab(const float* tab, size_t n, float a, float bi, T* tab_out) {
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         tab_out[i] = (T)floorf((tab[i] - bi) * a + 0.5);
     }
 }
@@ -68,7 +68,7 @@ void round_uint8_per_column(
         float* b_out) {
     float max_span = 0;
     std::vector<float> mins(n);
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         mins[i] = tab_min(tab + i * d, d);
         float span = tab_max(tab + i * d, d) - mins[i];
         if (span > max_span) {
@@ -77,7 +77,7 @@ void round_uint8_per_column(
     }
     float a = 255 / max_span;
     float b = 0;
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         b += mins[i];
         round_tab(tab + i * d, d, a, mins[i]);
     }
@@ -98,10 +98,10 @@ void round_uint8_per_column_multi(
         float* b_out) {
     float max_span = 0;
     std::vector<float> mins(n);
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         float min_i = HUGE_VAL;
         float max_i = -HUGE_VAL;
-        for (int j = 0; j < m; j++) {
+        for (size_t j = 0; j < m; j++) {
             min_i = std::min(min_i, tab_min(tab + (j * n + i) * d, d));
             max_i = std::max(max_i, tab_max(tab + (j * n + i) * d, d));
         }
@@ -113,9 +113,9 @@ void round_uint8_per_column_multi(
     }
     float a = 255 / max_span;
     float b = 0;
-    for (int i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         b += mins[i];
-        for (int j = 0; j < m; j++) {
+        for (size_t j = 0; j < m; j++) {
             round_tab(tab + (j * n + i) * d, d, a, mins[i]);
         }
     }
@@ -147,7 +147,7 @@ void quantize_LUT_and_bias(
         std::vector<float> mins(M);
         float max_span_LUT = -HUGE_VAL, max_span_dis = 0;
         b = 0;
-        for (int i = 0; i < M; i++) {
+        for (size_t i = 0; i < M; i++) {
             mins[i] = tab_min(LUT + i * ksub, ksub);
             float span = tab_max(LUT + i * ksub, ksub) - mins[i];
             max_span_LUT = std::max(max_span_LUT, span);
@@ -156,7 +156,7 @@ void quantize_LUT_and_bias(
         }
         a = std::min(255 / max_span_LUT, 65535 / max_span_dis);
 
-        for (int i = 0; i < M; i++) {
+        for (size_t i = 0; i < M; i++) {
             round_tab(LUT + i * ksub, ksub, a, mins[i], LUTq + i * ksub);
         }
         memset(LUTq + M * ksub, 0, ksub * (M2 - M));
@@ -167,7 +167,7 @@ void quantize_LUT_and_bias(
         float bias_max = tab_max(bias, nprobe);
         max_span_dis = bias_max - bias_min;
         b = 0;
-        for (int i = 0; i < M; i++) {
+        for (size_t i = 0; i < M; i++) {
             mins[i] = tab_min(LUT + i * ksub, ksub);
             float span = tab_max(LUT + i * ksub, ksub) - mins[i];
             max_span_LUT = std::max(max_span_LUT, span);
@@ -177,7 +177,7 @@ void quantize_LUT_and_bias(
         a = std::min(255 / max_span_LUT, 65535 / max_span_dis);
         b += bias_min;
 
-        for (int i = 0; i < M; i++) {
+        for (size_t i = 0; i < M; i++) {
             round_tab(LUT + i * ksub, ksub, a, mins[i], LUTq + i * ksub);
         }
         memset(LUTq + M * ksub, 0, ksub * (M2 - M));
@@ -192,10 +192,10 @@ void quantize_LUT_and_bias(
 
         b = HUGE_VAL;
         size_t ij = 0;
-        for (int j = 0; j < nprobe; j++) {
+        for (size_t j = 0; j < nprobe; j++) {
             float max_span_dis_j = bias[j] - bias_min;
             float b2j = bias[j];
-            for (int i = 0; i < M; i++) {
+            for (size_t i = 0; i < M; i++) {
                 mins[ij] = tab_min(LUT + ij * ksub, ksub);
                 float span = tab_max(LUT + ij * ksub, ksub) - mins[ij];
                 max_span_LUT = std::max(max_span_LUT, span);
@@ -212,8 +212,8 @@ void quantize_LUT_and_bias(
 
         ij = 0;
         size_t ij_2 = 0;
-        for (int j = 0; j < nprobe; j++) {
-            for (int i = 0; i < M; i++) {
+        for (size_t j = 0; j < nprobe; j++) {
+            for (size_t i = 0; i < M; i++) {
                 round_tab(
                         LUT + ij * ksub, ksub, a, mins[ij], LUTq + ij_2 * ksub);
                 ij++;
@@ -230,10 +230,10 @@ void quantize_LUT_and_bias(
         std::vector<float> LUT2_storage(nprobe * M * ksub);
         float* LUT2 = LUT2_storage.data();
         size_t ijc = 0;
-        for (int j = 0; j < nprobe; j++) {
+        for (size_t j = 0; j < nprobe; j++) {
             float bias_j = bias[j] / M;
-            for (int i = 0; i < M; i++) {
-                for (int c = 0; c < ksub; c++) {
+            for (size_t i = 0; i < M; i++) {
+                for (size_t c = 0; c < ksub; c++) {
                     LUT2[ijc] = LUT[ijc] + bias_j;
                     ijc++;
                 }
@@ -241,8 +241,8 @@ void quantize_LUT_and_bias(
         }
         std::vector<float> mins(M, HUGE_VAL), maxs(M, -HUGE_VAL);
         size_t ij = 0;
-        for (int j = 0; j < nprobe; j++) {
-            for (int i = 0; i < M; i++) {
+        for (size_t j = 0; j < nprobe; j++) {
+            for (size_t i = 0; i < M; i++) {
                 mins[i] = std::min(mins[i], tab_min(LUT2 + ij * ksub, ksub));
                 maxs[i] = std::max(maxs[i], tab_max(LUT2 + ij * ksub, ksub));
                 ij++;
@@ -251,7 +251,7 @@ void quantize_LUT_and_bias(
 
         float max_span = -HUGE_VAL;
         b = 0;
-        for (int i = 0; i < M; i++) {
+        for (size_t i = 0; i < M; i++) {
             float span = maxs[i] - mins[i];
             max_span = std::max(max_span, span);
             b += mins[i];
@@ -259,8 +259,8 @@ void quantize_LUT_and_bias(
         a = 255 / max_span;
         ij = 0;
         size_t ij_2 = 0;
-        for (int j = 0; j < nprobe; j++) {
-            for (int i = 0; i < M; i++) {
+        for (size_t j = 0; j < nprobe; j++) {
+            for (size_t i = 0; i < M; i++) {
                 round_tab(
                         LUT2 + ij * ksub, ksub, a, mins[i], LUTq + ij_2 * ksub);
                 ij++;
@@ -298,7 +298,7 @@ void aq_quantize_LUT_and_bias(
     float bias_max = tab_max(bias, nprobe);
     max_span_dis = bias_max - bias_min;
     b = 0;
-    for (int i = 0; i < M; i++) {
+    for (size_t i = 0; i < M; i++) {
         mins[i] = tab_min(LUT + i * ksub, ksub);
         float span = tab_max(LUT + i * ksub, ksub) - mins[i];
         max_span_LUT = std::max(max_span_LUT, span);
@@ -308,7 +308,7 @@ void aq_quantize_LUT_and_bias(
     a = std::min(255 / max_span_LUT, 65535 / max_span_dis);
     b += bias_min;
 
-    for (int i = 0; i < M; i++) {
+    for (size_t i = 0; i < M; i++) {
         round_tab(LUT + i * ksub, ksub, a, mins[i], LUTq + i * ksub);
     }
     memset(LUTq + M * ksub, 0, ksub * (M2 - M));
@@ -324,14 +324,14 @@ float aq_estimate_norm_scale(
         size_t M_norm,
         const float* LUT) {
     float max_span_LUT = -HUGE_VAL;
-    for (int i = 0; i < M - M_norm; i++) {
+    for (size_t i = 0; i < M - M_norm; i++) {
         float min = tab_min(LUT + i * ksub, ksub);
         float span = tab_max(LUT + i * ksub, ksub) - min;
         max_span_LUT = std::max(max_span_LUT, span);
     }
 
     float max_span_LUT_norm = -HUGE_VAL;
-    for (int i = M - M_norm; i < M; i++) {
+    for (size_t i = M - M_norm; i < M; i++) {
         float min = tab_min(LUT + i * ksub, ksub);
         float span = tab_max(LUT + i * ksub, ksub) - min;
         max_span_LUT_norm = std::max(max_span_LUT_norm, span);

data/vendor/faiss/faiss/utils/quantize_lut.h

@@ -50,7 +50,7 @@ void round_uint8_per_column_multi(
 
 /** LUT quantization to uint8 and bias to uint16.
  *
- * (nprobe, M, ksub, lut_is_3d) determine the size of the the LUT
+ * (nprobe, M, ksub, lut_is_3d) determine the size of the LUT
  *
  *  LUT input:
  *  - 2D size (M, ksub): single matrix per probe (lut_is_3d=false)