faiss 0.1.2 → 0.1.3

data/vendor/faiss/{IVFlib.cpp → faiss/IVFlib.cpp}

@@ -14,6 +14,7 @@
 #include <faiss/IndexPreTransform.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/MetaIndexes.h>
+#include <faiss/utils/utils.h>
 
 
 
@@ -180,9 +181,9 @@ SlidingIndexWindow::SlidingIndexWindow (Index *index): index (index) {
     n_slice = 0;
     IndexIVF* index_ivf = const_cast<IndexIVF*>(extract_index_ivf (index));
     ils = dynamic_cast<ArrayInvertedLists *> (index_ivf->invlists);
-    nlist = ils->nlist;
     FAISS_THROW_IF_NOT_MSG (ils,
                "only supports indexes with ArrayInvertedLists");
+    nlist = ils->nlist;
     sizes.resize(nlist);
 }
 
@@ -310,17 +311,34 @@ void set_invlist_range (Index *index, long i0, long i1,
     ivf->ntotal = index->ntotal = ntotal;
 }
 
+static size_t count_ndis(const IndexIVF * index_ivf, size_t n_list_scan,
+                         const idx_t *Iq)
+{
+    size_t nb_dis = 0;
+    const InvertedLists *il = index_ivf->invlists;
+    for (idx_t i = 0; i < n_list_scan; i++) {
+        if (Iq[i] >= 0) {
+            nb_dis += il->list_size(Iq[i]);
+        }
+    }
+    return nb_dis;
+}
+
+
 
 void search_with_parameters (const Index *index,
                              idx_t n, const float *x, idx_t k,
                              float *distances, idx_t *labels,
-                             IVFSearchParameters *params,
-                             size_t *nb_dis_ptr)
+                             const IVFSearchParameters *params,
+                             size_t *nb_dis_ptr,
+                             double *ms_per_stage)
 {
     FAISS_THROW_IF_NOT (params);
     const float *prev_x = x;
     ScopeDeleter<float> del;
 
+    double t0 = getmillisecs();
+
     if (auto ip = dynamic_cast<const IndexPreTransform *> (index)) {
         x = ip->apply_chain (n, x);
         if (x != prev_x) {
@@ -329,6 +347,8 @@ void search_with_parameters (const Index *index,
         index = ip->index;
     }
 
+    double t1 = getmillisecs();
+
     std::vector<idx_t> Iq(params->nprobe * n);
     std::vector<float> Dq(params->nprobe * n);
 
@@ -339,21 +359,76 @@ void search_with_parameters (const Index *index,
                                  Dq.data(), Iq.data());
 
     if (nb_dis_ptr) {
-        size_t nb_dis = 0;
-        const InvertedLists *il = index_ivf->invlists;
-        for (idx_t i = 0; i < n * params->nprobe; i++) {
-          if (Iq[i] >= 0) {
-              nb_dis += il->list_size(Iq[i]);
-          }
-        }
-        *nb_dis_ptr = nb_dis;
+        *nb_dis_ptr = count_ndis (index_ivf,  n * params->nprobe, Iq.data());
     }
 
+    double t2 = getmillisecs();
+
     index_ivf->search_preassigned(n, x, k, Iq.data(), Dq.data(),
                                   distances, labels,
                                   false, params);
+    double t3 = getmillisecs();
+    if (ms_per_stage) {
+        ms_per_stage[0] = t1 - t0;
+        ms_per_stage[1] = t2 - t1;
+        ms_per_stage[2] = t3 - t2;
+    }
+}
+
+void range_search_with_parameters (const Index *index,
+                                   idx_t n, const float *x, float radius,
+                                   RangeSearchResult *result,
+                                   const IVFSearchParameters *params,
+                                   size_t *nb_dis_ptr,
+                                   double *ms_per_stage)
+{
+    FAISS_THROW_IF_NOT (params);
+    const float *prev_x = x;
+    ScopeDeleter<float> del;
+
+    double t0 = getmillisecs();
+
+    if (auto ip = dynamic_cast<const IndexPreTransform *> (index)) {
+        x = ip->apply_chain (n, x);
+        if (x != prev_x) {
+            del.set(x);
+        }
+        index = ip->index;
+    }
+
+    double t1 = getmillisecs();
+
+    std::vector<idx_t> Iq(params->nprobe * n);
+    std::vector<float> Dq(params->nprobe * n);
+
+    const IndexIVF *index_ivf = dynamic_cast<const IndexIVF *>(index);
+    FAISS_THROW_IF_NOT (index_ivf);
+
+    index_ivf->quantizer->search(n, x, params->nprobe,
+                                 Dq.data(), Iq.data());
+
+    if (nb_dis_ptr) {
+        *nb_dis_ptr = count_ndis (index_ivf,  n * params->nprobe, Iq.data());
+    }
+
+    double t2 = getmillisecs();
+
+    index_ivf->range_search_preassigned(
+            n, x, radius, Iq.data(), Dq.data(),
+            result, false, params
+    );
+
+    double t3 = getmillisecs();
+    if (ms_per_stage) {
+        ms_per_stage[0] = t1 - t0;
+        ms_per_stage[1] = t2 - t1;
+        ms_per_stage[2] = t3 - t2;
+    }
 }
 
 
 
+
+
+
 } } // namespace faiss::ivflib

data/vendor/faiss/{IVFlib.h → faiss/IVFlib.h}

@@ -120,14 +120,32 @@ ArrayInvertedLists * get_invlist_range (const Index *index,
 void set_invlist_range (Index *index, long i0, long i1,
                         ArrayInvertedLists * src);
 
-// search an IndexIVF, possibly embedded in an IndexPreTransform with
-// given parameters. Optionally returns the number of distances
-// computed
-void search_with_parameters (const Index *index,
-                             idx_t n, const float *x, idx_t k,
-                             float *distances, idx_t *labels,
-                             IVFSearchParameters *params,
-                             size_t *nb_dis = nullptr);
+/** search an IndexIVF, possibly embedded in an IndexPreTransform with
+ * given parameters. This is a way to set the nprobe and get
+ * statdistics in a thread-safe way.
+ *
+ * Optionally returns (if non-nullptr):
+ * - nb_dis: number of distances computed
+ * - ms_per_stage: [0]: preprocessing time
+ *                 [1]: coarse quantization,
+ *                 [2]: list scanning
+ */
+void search_with_parameters (
+        const Index *index,
+        idx_t n, const float *x, idx_t k,
+        float *distances, idx_t *labels,
+        const IVFSearchParameters *params,
+        size_t *nb_dis = nullptr,
+        double *ms_per_stage = nullptr);
+
+/** same as search_with_parameters but for range search */
+void range_search_with_parameters (
+        const Index *index,
+        idx_t n, const float *x, float radius,
+        RangeSearchResult *result,
+        const IVFSearchParameters *params,
+        size_t *nb_dis = nullptr,
+        double *ms_per_stage = nullptr);
 
 
 

data/vendor/faiss/{Index.h → faiss/Index.h}

@@ -18,7 +18,7 @@
 
 #define FAISS_VERSION_MAJOR 1
 #define FAISS_VERSION_MINOR 6
-#define FAISS_VERSION_PATCH 3
+#define FAISS_VERSION_PATCH 4
 
 /**
  * @namespace faiss

data/vendor/faiss/{Index2Layer.cpp → faiss/Index2Layer.cpp}

@@ -9,12 +9,13 @@
 
 #include <faiss/Index2Layer.h>
 
+#include <cinttypes>
 #include <cmath>
 #include <cstdio>
 #include <cassert>
 #include <stdint.h>
 
-#ifdef __SSE__
+#ifdef __SSE3__
 #include <immintrin.h>
 #endif
 
@@ -77,7 +78,7 @@ Index2Layer::~Index2Layer ()
 void Index2Layer::train(idx_t n, const float* x)
 {
     if (verbose) {
-        printf ("training level-1 quantizer %ld vectors in %dD\n",
+        printf ("training level-1 quantizer %" PRId64 " vectors in %dD\n",
                 n, d);
     }
 
@@ -104,7 +105,7 @@ void Index2Layer::train(idx_t n, const float* x)
     }
 
     if (verbose)
-        printf ("training %zdx%zd product quantizer on %ld vectors in %dD\n",
+        printf ("training %zdx%zd product quantizer on %" PRId64 " vectors in %dD\n",
                 pq.M, pq.ksub, n, d);
     pq.verbose = verbose;
     pq.train (n, residuals.data());
@@ -119,7 +120,7 @@ void Index2Layer::add(idx_t n, const float* x)
         for (idx_t i0 = 0; i0 < n; i0 += bs) {
             idx_t i1 = std::min(i0 + bs, n);
             if (verbose) {
-                printf("Index2Layer::add: adding %ld:%ld / %ld\n",
+                printf("Index2Layer::add: adding %" PRId64 ":%" PRId64 " / %" PRId64 "\n",
                        i0, i1, n);
             }
             add (i1 - i0, x + i0 * d);
@@ -172,14 +173,14 @@ void Index2Layer::search(
 
 void Index2Layer::reconstruct_n(idx_t i0, idx_t ni, float* recons) const
 {
-    float recons1[d];
+    std::vector<float> recons1(d);
     FAISS_THROW_IF_NOT (i0 >= 0 && i0 + ni <= ntotal);
     const uint8_t *rp = &codes[i0 * code_size];
 
     for (idx_t i = 0; i < ni; i++) {
         idx_t key = 0;
         memcpy (&key, rp, code_size_1);
-        q1.quantizer->reconstruct (key, recons1);
+        q1.quantizer->reconstruct (key, recons1.data());
         rp += code_size_1;
         pq.decode (rp, recons);
         for (idx_t j = 0; j < d; j++) {
@@ -270,7 +271,7 @@ struct DistanceXPQ4 : Distance2Level {
     }
 
     float operator () (idx_t i) override {
-#ifdef __SSE__
+#ifdef __SSE3__
         const uint8_t *code = storage.codes.data() + i * storage.code_size;
         long key = 0;
         memcpy (&key, code, storage.code_size_1);
@@ -323,7 +324,7 @@ struct Distance2xXPQ4 : Distance2Level {
         long key01 = 0;
         memcpy (&key01, code, storage.code_size_1);
         code += storage.code_size_1;
-#ifdef __SSE__
+#ifdef __SSE3__
 
         // walking pointers
         const float *qa = q;
@@ -361,7 +362,7 @@ struct Distance2xXPQ4 : Distance2Level {
 
 
 DistanceComputer * Index2Layer::get_distance_computer() const {
-#ifdef __SSE__
+#ifdef __SSE3__
     const MultiIndexQuantizer *mi =
         dynamic_cast<MultiIndexQuantizer*> (q1.quantizer);
 
@@ -416,13 +417,13 @@ void Index2Layer::sa_decode (idx_t n, const uint8_t *bytes, float *x) const
         std::vector<float> residual (d);
 
 #pragma omp for
-        for (size_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < n; i++) {
             const uint8_t *code = bytes + i * code_size;
             int64_t list_no = q1.decode_listno (code);
             float *xi = x + i * d;
             pq.decode (code + code_size_1, xi);
             q1.quantizer->reconstruct (list_no, residual.data());
-            for (size_t j = 0; j < d; j++) {
+            for (int j = 0; j < d; j++) {
                 xi[j] += residual[j];
             }
         }

data/vendor/faiss/{IndexBinary.cpp → faiss/IndexBinary.cpp}

@@ -10,6 +10,7 @@
 #include <faiss/IndexBinary.h>
 #include <faiss/impl/FaissAssert.h>
 
+#include <cinttypes>
 #include <cstring>
 
 namespace faiss {
@@ -70,7 +71,7 @@ void IndexBinary::search_and_reconstruct(idx_t n, const uint8_t *x, idx_t k,
 }
 
 void IndexBinary::display() const {
-  printf("Index: %s  -> %ld elements\n", typeid (*this).name(), ntotal);
+  printf("Index: %s  -> %" PRId64 " elements\n", typeid (*this).name(), ntotal);
 }
 
 

data/vendor/faiss/{IndexBinaryFromFloat.cpp → faiss/IndexBinaryFromFloat.cpp}

@@ -9,6 +9,7 @@
 
 #include <faiss/IndexBinaryFromFloat.h>
 
+#include <algorithm>
 #include <memory>
 #include <faiss/utils/utils.h>
 

data/vendor/faiss/{IndexBinaryHNSW.cpp → faiss/IndexBinaryHNSW.cpp}

@@ -23,7 +23,6 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h>
 #include <stdint.h>
 
 #include <faiss/utils/random.h>
@@ -52,7 +51,7 @@ void hnsw_add_vertices(IndexBinaryHNSW& index_hnsw,
   size_t ntotal = n0 + n;
   double t0 = getmillisecs();
   if (verbose) {
-    printf("hnsw_add_vertices: adding %ld elements on top of %ld "
+    printf("hnsw_add_vertices: adding %zd elements on top of %zd "
            "(preset_levels=%d)\n",
            n, n0, int(preset_levels));
   }

data/vendor/faiss/{IndexBinaryHash.cpp → faiss/IndexBinaryHash.cpp}

@@ -5,11 +5,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-// Copyright 2004-present Facebook. All Rights Reserved
 // -*- c++ -*-
 
 #include <faiss/IndexBinaryHash.h>
 
+#include <cinttypes>
 #include <cstdio>
 #include <memory>
 
@@ -19,6 +19,15 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 
+#ifdef _MSC_VER
+#include <intrin.h>
+
+static inline int __builtin_ctzll(uint64_t x) {
+    unsigned long ret;
+    _BitScanForward64(&ret, x);
+    return (int)ret;
+}
+#endif // _MSC_VER
 
 namespace faiss {
 
@@ -222,7 +231,7 @@ void IndexBinaryHash::range_search(idx_t n, const uint8_t *x, int radius,
         RangeSearchPartialResult pres (result);
 
 #pragma omp for
-        for (size_t i = 0; i < n; i++) { // loop queries
+        for (idx_t i = 0; i < n; i++) { // loop queries
             RangeQueryResult & qres = pres.new_result (i);
             RangeSearchResults res = {radius, qres};
             const uint8_t *q = x + i * code_size;
@@ -246,7 +255,7 @@ void IndexBinaryHash::search(idx_t n, const uint8_t *x, idx_t k,
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel for if(n > 100) reduction(+: nlist, ndis, n0)
-    for (size_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         int32_t * simi = distances + k * i;
         idx_t * idxi = labels + k * i;
 
@@ -272,10 +281,10 @@ size_t IndexBinaryHash::hashtable_size() const
 void IndexBinaryHash::display() const
 {
     for (auto it = invlists.begin(); it != invlists.end(); ++it) {
-        printf("%ld: [", it->first);
+        printf("%" PRId64 ": [", it->first);
         const std::vector<idx_t> & v = it->second.ids;
         for (auto x: v) {
-            printf("%ld ", 0 + x);
+            printf("%" PRId64 " ", x);
         }
         printf("]\n");
 
@@ -437,7 +446,7 @@ void IndexBinaryMultiHash::range_search(idx_t n, const uint8_t *x, int radius,
         RangeSearchPartialResult pres (result);
 
 #pragma omp for
-        for (size_t i = 0; i < n; i++) { // loop queries
+        for (idx_t i = 0; i < n; i++) { // loop queries
             RangeQueryResult & qres = pres.new_result (i);
             RangeSearchResults res = {radius, qres};
             const uint8_t *q = x + i * code_size;
@@ -461,7 +470,7 @@ void IndexBinaryMultiHash::search(idx_t n, const uint8_t *x, idx_t k,
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel for if(n > 100) reduction(+: nlist, ndis, n0)
-    for (size_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         int32_t * simi = distances + k * i;
         idx_t * idxi = labels + k * i;
 

data/vendor/faiss/{IndexBinaryHash.h → faiss/IndexBinaryHash.h}

@@ -17,6 +17,7 @@
 
 #include <faiss/IndexBinary.h>
 #include <faiss/IndexBinaryFlat.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/utils/Heap.h>
 
 
@@ -71,7 +72,7 @@ struct IndexBinaryHashStats {
     void reset ();
 };
 
-extern IndexBinaryHashStats indexBinaryHash_stats;
+FAISS_API extern IndexBinaryHashStats indexBinaryHash_stats;
 
 
 /** just uses the b first bits as a hash value */