faiss 0.4.3 → 0.5.1

data/vendor/faiss/faiss/utils/Heap.h

@@ -150,7 +150,7 @@ inline void heap_replace_top(
     bh_ids[i] = id;
 }
 
-/* Partial instanciation for heaps with TI = int64_t */
+/* Partial instantiation for heaps with TI = int64_t */
 
 template <typename T>
 inline void minheap_pop(size_t k, T* bh_val, int64_t* bh_ids) {
@@ -393,7 +393,7 @@ inline void heap_addn(
     }
 }
 
-/* Partial instanciation for heaps with TI = int64_t */
+/* Partial instantiation for heaps with TI = int64_t */
 
 template <typename T>
 inline void minheap_addn(
@@ -489,7 +489,7 @@ struct HeapArray {
         return val + key * k;
     }
 
-    /// Correspponding identifiers
+    /// Corresponding identifiers
     TI* get_ids(size_t key) {
         return ids + key * k;
     }

data/vendor/faiss/faiss/utils/NeuralNet.cpp

@@ -71,7 +71,7 @@ Tensor2DTemplate<T> Tensor2DTemplate<T>::column(size_t j) const {
     return out;
 }
 
-// explicit template instanciation
+// explicit template instantiation
 template struct Tensor2DTemplate<float>;
 template struct Tensor2DTemplate<int32_t>;
 

data/vendor/faiss/faiss/utils/NeuralNet.h

@@ -75,7 +75,7 @@ struct Embedding {
 };
 
 /// Feed forward layer that expands to a hidden dimension, applies a ReLU non
-/// linearity and maps back to the orignal dimension
+/// linearity and maps back to the original dimension
 struct FFN {
     Linear linear1, linear2;
 
@@ -103,7 +103,7 @@ struct QINCoStep {
         return residual_blocks[i];
     }
 
-    /** encode a set of vectors x with intial estimate xhat. Optionally return
+    /** encode a set of vectors x with initial estimate xhat. Optionally return
      * the delta to be added to xhat to form the new xhat */
     nn::Int32Tensor2D encode(
             const nn::Tensor2D& xhat,
@@ -141,7 +141,7 @@ struct QINCo : NeuralNetCodec {
 
     nn::Int32Tensor2D encode(const nn::Tensor2D& x) const override;
 
-    virtual ~QINCo() {}
+    virtual ~QINCo() override {}
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/utils/approx_topk/approx_topk.h

@@ -50,8 +50,8 @@
 //        for j in range(0, NBUCKETS):
 //          idx = beam * n + i * NBUCKETS + j
 //          if distances[idx] < local_min_distances[j]:
-//            local_min_distances[i] = distances[idx]
-//            local_min_indices[i] = indices[idx]
+//            local_min_distances[j] = distances[idx]
+//            local_min_indices[j] = indices[idx]
 //
 //    for j in range(0, NBUCKETS):
 //      heap.push(local_min_distances[j], local_min_indices[j])

data/vendor/faiss/faiss/utils/approx_topk/avx2-inl.h

@@ -106,7 +106,7 @@ struct HeapWithBuckets<CMax<float, int>, NBUCKETS, N> {
                                 distance_candidate,
                                 _CMP_LE_OS);
 
-                        // // blend seems to be slower that min
+                        // // blend seems to be slower than min
                         // const __m256 min_distances_new = _mm256_blendv_ps(
                         //         distance_candidate,
                         //         min_distances_i[j][p],
@@ -120,7 +120,7 @@ struct HeapWithBuckets<CMax<float, int>, NBUCKETS, N> {
                                                 min_indices_i[j][p]),
                                         comparison));
 
-                        // // blend seems to be slower that min
+                        // // blend seems to be slower than min
                         // const __m256 max_distances_new = _mm256_blendv_ps(
                         //         min_distances_i[j][p],
                         //         distance_candidate,

data/vendor/faiss/faiss/utils/approx_topk/mode.h

@@ -21,7 +21,7 @@
 /// It seems that only the limited number of combinations are
 /// meaningful, because of the limited supply of SIMD registers.
 /// Also, certain combinations, such as B32_D1 and B16_D1, were concluded
-/// to be not very precise in benchmarks, so ones were not introduced.
+/// to be not very precise in benchmarks, so they were not introduced.
 ///
 /// TODO: Consider d-ary SIMD heap.
 

data/vendor/faiss/faiss/utils/distances.cpp

@@ -321,7 +321,6 @@ void exhaustive_L2sqr_blas_default_impl(
                        ip_block.get(),
                        &nyi);
             }
-#pragma omp parallel for
             for (int64_t i = i0; i < i1; i++) {
                 float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
 
@@ -423,7 +422,6 @@ void exhaustive_L2sqr_blas_cmax_avx2(
                        ip_block.get(),
                        &nyi);
             }
-#pragma omp parallel for
             for (int64_t i = i0; i < i1; i++) {
                 float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
 
@@ -633,7 +631,6 @@ void exhaustive_L2sqr_blas_cmax_sve(
                        ip_block.get(),
                        &nyi);
             }
-#pragma omp parallel for
             for (int64_t i = i0; i < i1; i++) {
                 const size_t count = j1 - j0;
                 float* ip_line = ip_block.get() + (i - i0) * count;

data/vendor/faiss/faiss/utils/distances.h

@@ -324,7 +324,7 @@ void knn_inner_product(
  *  vector y, for the L2 distance
  * @param x    query vectors, size nx * d
  * @param y    database vectors, size ny * d
- * @param res  result heap strcture, which also provides k. Sorted on output
+ * @param res  result heap structure, which also provides k. Sorted on output
  * @param y_norm2    (optional) norms for the y vectors (nullptr or size ny)
  * @param sel  search in this subset of vectors
  */
@@ -389,7 +389,7 @@ void knn_inner_products_by_idx(
  * @param x    query vectors, size nx * d
  * @param y    database vectors, size (max(ids) + 1) * d
  * @param subset subset of database vectors to consider, size (nx, nsubset)
- * @param res  rIDesult structure
+ * @param res  result structure
  * @param ld_subset stride for the subset array. -1: use nsubset, 0: all queries
  * process the same subset
  */

data/vendor/faiss/faiss/utils/extra_distances-inl.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#pragma once
+
 /** In this file are the implementations of extra metrics beyond L2
  *  and inner product */
 
@@ -188,7 +190,7 @@ inline float VectorDistance<METRIC_GOWER>::operator()(
 
 /***************************************************************************
  * Dispatching function that takes a metric type and a consumer object
- * the consumer object should contain a retun type T and a operation template
+ * the consumer object should contain a return type T and a operation template
  * function f() that is called to perform the operation. The first argument
  * of the function is the VectorDistance object. The rest are passed in as is.
  **************************************************************************/

data/vendor/faiss/faiss/utils/hamming-inl.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#pragma once
+
 namespace faiss {
 
 // BitstringWriter and BitstringReader functions

data/vendor/faiss/faiss/utils/hamming.cpp

@@ -257,12 +257,13 @@ void hammings_knn_mc(
 
     std::vector<HCounterState<HammingComputer>> cs;
     for (size_t i = 0; i < na; ++i) {
-        cs.push_back(HCounterState<HammingComputer>(
-                all_counters.data() + i * nBuckets,
-                all_ids_per_dis.get() + i * nBuckets * k,
-                a + i * bytes_per_code,
-                8 * bytes_per_code,
-                k));
+        cs.push_back(
+                HCounterState<HammingComputer>(
+                        all_counters.data() + i * nBuckets,
+                        all_ids_per_dis.get() + i * nBuckets * k,
+                        a + i * bytes_per_code,
+                        8 * bytes_per_code,
+                        k));
     }
 
     const size_t block_size = hamming_batch_size;

data/vendor/faiss/faiss/utils/hamming.h

@@ -14,7 +14,7 @@
  * fvecs2bitvecs).
  *
  * User-defined type hamdis_t is used for distances because at this time
- * it is still uncler clear how we will need to balance
+ * it is still unclear clear how we will need to balance
  * - flexibility in vector size (may need 16- or even 8-bit vectors)
  * - memory usage
  * - cache-misses when dealing with large volumes of data (fewer bits is better)

data/vendor/faiss/faiss/utils/hamming_distance/common.h

@@ -30,8 +30,7 @@ inline int popcount64(uint64_t x) {
 // This table was moved from .cpp to .h file, because
 // otherwise it was causing compilation errors while trying to
 // compile swig modules on Windows.
-// todo for C++17: switch to 'inline constexpr'
-static constexpr uint8_t hamdis_tab_ham_bytes[256] = {
+inline constexpr uint8_t hamdis_tab_ham_bytes[256] = {
         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
         2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,

data/vendor/faiss/faiss/utils/partitioning.cpp

@@ -140,7 +140,7 @@ typename C::T partition_fuzzy_median3(
     using T = typename C::T;
 
     // here we use bissection with a median of 3 to find the threshold and
-    // compress the arrays afterwards. So it's a n*log(n) algoirithm rather than
+    // compress the arrays afterwards. So it's a n*log(n) algorithm rather than
     // qselect's O(n) but it avoids shuffling around the array.
 
     FAISS_THROW_IF_NOT(n >= 3);
@@ -350,7 +350,7 @@ int simd_compress_array(
         }
     }
 
-    // handle remaining, only striclty lt ones.
+    // handle remaining, only strictly lt ones.
     for (; i0 + 15 < n; i0 += 16) {
         simd16uint16 v(vals + i0);
         simd16uint16 max2 = max_func<C>(v, thr16);
@@ -506,7 +506,7 @@ uint16_t simd_partition_fuzzy_with_bounds(
 
     uint64_t t2 = get_cy();
 
-    partition_stats.bissect_cycles += t1 - t0;
+    partition_stats.bisect_cycles += t1 - t0;
     partition_stats.compress_cycles += t2 - t1;
 
     return thresh;
@@ -662,7 +662,7 @@ uint16_t simd_partition_fuzzy_with_bounds_histogram(
         }
     }
 
-    IFV printf("end bissection: thresh=%d q=%ld n_eq=%ld\n", thresh, q, n_eq);
+    IFV printf("end bisection: thresh=%d q=%ld n_eq=%ld\n", thresh, q, n_eq);
 
     if (!C::is_max) {
         if (n_eq == 0) {
@@ -762,7 +762,7 @@ typename C::T partition_fuzzy(
             vals, ids, n, q_min, q_max, q_out);
 }
 
-// explicit template instanciations
+// explicit template instantiations
 
 template float partition_fuzzy<CMin<float, int64_t>>(
         float* vals,

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

@@ -28,7 +28,7 @@ typename C::T partition_fuzzy(
         size_t q_max,
         size_t* q_out);
 
-/** simplified interface for when the parition is not fuzzy */
+/** simplified interface for when the partition is not fuzzy */
 template <class C>
 inline typename C::T partition(
         typename C::T* vals,
@@ -59,7 +59,7 @@ void simd_histogram_16(
         int* hist);
 
 struct PartitionStats {
-    uint64_t bissect_cycles;
+    uint64_t bisect_cycles;
     uint64_t compress_cycles;
 
     PartitionStats() {