faiss 0.1.2 → 0.1.3

data/vendor/faiss/{impl → faiss/impl}/FaissAssert.h

@@ -11,6 +11,7 @@
 #define FAISS_ASSERT_INCLUDED
 
 #include <faiss/impl/FaissException.h>
+#include <faiss/impl/platform_macros.h>
 #include <cstdlib>
 #include <cstdio>
 #include <string>

data/vendor/faiss/{impl → faiss/impl}/FaissException.cpp

@@ -10,6 +10,10 @@
 #include <faiss/impl/FaissException.h>
 #include <sstream>
 
+#ifdef  __GNUG__
+#include <cxxabi.h>
+#endif
+
 namespace faiss {
 
 FaissException::FaissException(const std::string& m)
@@ -63,4 +67,26 @@ void handleExceptions(
   }
 }
 
+
+// From
+// https://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname
+
+std::string demangle_cpp_symbol(const char* name) {
+#ifdef __GNUG__
+    int status = -1;
+    const char * res = abi::__cxa_demangle(name, nullptr, nullptr, &status);
+    std::string sres;
+    if (status == 0) {
+        sres = res;
+    }
+    free((void*)res);
+    return sres;
+#else
+    // don't know how to do this on other platforms
+    return std::string(name);
+#endif
 }
+
+
+
+} // namespace

data/vendor/faiss/{impl → faiss/impl}/FaissException.h

@@ -66,6 +66,10 @@ struct ScopeDeleter1 {
     }
 };
 
+/// make typeids more readable
+std::string demangle_cpp_symbol(const char* name);
+
+
 }
 
 #endif

data/vendor/faiss/{impl → faiss/impl}/HNSW.cpp

@@ -157,11 +157,11 @@ void HNSW::print_neighbor_stats(int level) const
     }
   }
   float normalizer = n_node;
-  printf("   nb of nodes at that level %ld\n", n_node);
-  printf("   neighbors per node: %.2f (%ld)\n",
+  printf("   nb of nodes at that level %zd\n", n_node);
+  printf("   neighbors per node: %.2f (%zd)\n",
          tot_neigh / normalizer, tot_neigh);
   printf("   nb of reciprocal neighbors: %.2f\n", tot_reciprocal / normalizer);
-  printf("   nb of neighbors that are also neighbor-of-neighbors: %.2f (%ld)\n",
+  printf("   nb of neighbors that are also neighbor-of-neighbors: %.2f (%zd)\n",
          tot_common / normalizer, tot_common);
 
 
@@ -181,7 +181,7 @@ void HNSW::fill_with_random_links(size_t n)
         elts.push_back(i);
       }
     }
-    printf ("linking %ld elements in level %d\n",
+    printf ("linking %zd elements in level %d\n",
             elts.size(), level);
 
     if (elts.size() == 1) continue;
@@ -527,6 +527,7 @@ int HNSW::search_from_candidates(
   idx_t *I, float *D,
   MinimaxHeap& candidates,
   VisitedTable& vt,
+  HNSWStats& stats,
   int level, int nres_in) const
 {
   int nres = nres_in;
@@ -590,14 +591,11 @@ int HNSW::search_from_candidates(
   }
 
   if (level == 0) {
-#pragma omp critical
-    {
-      hnsw_stats.n1 ++;
-      if (candidates.size() == 0) {
-        hnsw_stats.n2 ++;
-      }
-      hnsw_stats.n3 += ndis;
+    stats.n1 ++;
+    if (candidates.size() == 0) {
+      stats.n2 ++;
     }
+    stats.n3 += ndis;
   }
 
   return nres;
@@ -612,7 +610,8 @@ std::priority_queue<HNSW::Node> HNSW::search_from_candidate_unbounded(
   const Node& node,
   DistanceComputer& qdis,
   int ef,
-  VisitedTable *vt) const
+  VisitedTable *vt,
+  HNSWStats& stats) const
 {
   int ndis = 0;
   std::priority_queue<Node> top_candidates;
@@ -663,22 +662,21 @@ std::priority_queue<HNSW::Node> HNSW::search_from_candidate_unbounded(
     }
   }
 
-#pragma omp critical
-  {
-    ++hnsw_stats.n1;
-    if (candidates.size() == 0) {
-      ++hnsw_stats.n2;
-    }
-    hnsw_stats.n3 += ndis;
+  ++stats.n1;
+  if (candidates.size() == 0) {
+    ++stats.n2;
   }
+  stats.n3 += ndis;
 
   return top_candidates;
 }
 
-void HNSW::search(DistanceComputer& qdis, int k,
-                  idx_t *I, float *D,
-                  VisitedTable& vt) const
+HNSWStats HNSW::search(DistanceComputer& qdis, int k,
+                       idx_t *I, float *D,
+                       VisitedTable& vt) const
 {
+  HNSWStats stats;
+
   if (upper_beam == 1) {
 
     //  greedy search on upper levels
@@ -695,11 +693,11 @@ void HNSW::search(DistanceComputer& qdis, int k,
 
       candidates.push(nearest, d_nearest);
 
-      search_from_candidates(qdis, k, I, D, candidates, vt, 0);
+      search_from_candidates(qdis, k, I, D, candidates, vt, stats, 0);
     } else {
       std::priority_queue<Node> top_candidates =
         search_from_candidate_unbounded(Node(d_nearest, nearest),
-                                        qdis, ef, &vt);
+                                        qdis, ef, &vt, stats);
 
       while (top_candidates.size() > k) {
         top_candidates.pop();
@@ -739,17 +737,19 @@ void HNSW::search(DistanceComputer& qdis, int k,
       }
 
       if (level == 0) {
-        nres = search_from_candidates(qdis, k, I, D, candidates, vt, 0);
+        nres = search_from_candidates(qdis, k, I, D, candidates, vt, stats, 0);
       } else  {
         nres = search_from_candidates(
           qdis, candidates_size,
           I_to_next.data(), D_to_next.data(),
-          candidates, vt, level
+          candidates, vt, stats, level
         );
       }
       vt.advance();
     }
   }
+
+  return stats;
 }
 
 

data/vendor/faiss/{impl → faiss/impl}/HNSW.h

@@ -19,6 +19,7 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/random.h>
 #include <faiss/utils/Heap.h>
+#include <faiss/impl/platform_macros.h>
 
 
 namespace faiss {
@@ -43,6 +44,7 @@ namespace faiss {
 
 struct VisitedTable;
 struct DistanceComputer; // from AuxIndexStructures
+struct HNSWStats;
 
 struct HNSW {
   /// internal storage of vectors (32 bits: this is expensive)
@@ -186,19 +188,20 @@ struct HNSW {
                              idx_t *I, float *D,
                              MinimaxHeap& candidates,
                              VisitedTable &vt,
+                             HNSWStats &stats,
                              int level, int nres_in = 0) const;
 
   std::priority_queue<Node> search_from_candidate_unbounded(
     const Node& node,
     DistanceComputer& qdis,
     int ef,
-    VisitedTable *vt
-  ) const;
+    VisitedTable *vt,
+    HNSWStats &stats) const;
 
   /// search interface
-  void search(DistanceComputer& qdis, int k,
-              idx_t *I, float *D,
-              VisitedTable& vt) const;
+  HNSWStats search(DistanceComputer& qdis, int k,
+                   idx_t *I, float *D,
+                   VisitedTable &vt) const;
 
   void reset();
 
@@ -254,22 +257,27 @@ struct HNSWStats {
   size_t n1, n2, n3;
   size_t ndis;
   size_t nreorder;
-  bool view;
 
-  HNSWStats() {
-    reset();
-  }
+  HNSWStats(size_t n1 = 0, size_t n2 = 0, size_t n3 = 0, size_t ndis = 0, size_t nreorder = 0)
+    : n1(n1), n2(n2), n3(n3), ndis(ndis), nreorder(nreorder) {}
 
   void reset() {
     n1 = n2 = n3 = 0;
     ndis = 0;
     nreorder = 0;
-    view = false;
+  }
+
+  void combine(const HNSWStats& other) {
+    n1 += other.n1;
+    n2 += other.n2;
+    n3 += other.n3;
+    ndis += other.ndis;
+    nreorder += other.nreorder;
   }
 };
 
 // global var that collects them all
-extern HNSWStats hnsw_stats;
+FAISS_API extern HNSWStats hnsw_stats;
 
 
 }  // namespace faiss

data/vendor/faiss/{impl → faiss/impl}/PolysemousTraining.cpp

@@ -893,7 +893,7 @@ void PolysemousTraining::optimize_ranking (
         ScopeDeleter1<PermutationObjective> del (obj);
 
         if (verbose > 0) {
-            printf("   m=%d, nq=%ld, nb=%ld, intialize RankingScore "
+            printf("   m=%d, nq=%zd, nb=%zd, intialize RankingScore "
                    "in %.3f ms\n",
                    m, nq, nb, getmillisecs () - t0);
         }

data/vendor/faiss/{impl → faiss/impl}/PolysemousTraining.h

@@ -101,7 +101,7 @@ struct RandomGenerator;
                                  const SimulatedAnnealingParameters &p);
     RandomGenerator *rnd;
 
-    /// remember intial cost of optimization
+    /// remember initial cost of optimization
     double init_cost;
 
     // main entry point. Perform the optimization loop, starting from

data/vendor/faiss/{impl → faiss/impl}/ProductQuantizer-inl.h

@@ -134,5 +134,4 @@ uint64_t PQDecoder16::decode() {
     return (uint64_t)(*code++);
 }
 
-
 } // namespace faiss

data/vendor/faiss/{impl → faiss/impl}/ProductQuantizer.cpp

@@ -261,7 +261,7 @@ void ProductQuantizer::train (int n, const float * x)
             train_type == Train_hypercube_pca) {
             if (dsub < nbits) {
                 final_train_type = Train_default;
-                printf ("cannot train hypercube: nbits=%ld > log2(d=%ld)\n",
+                printf ("cannot train hypercube: nbits=%zd > log2(d=%zd)\n",
                         nbits, dsub);
             }
         }
@@ -329,14 +329,14 @@ void ProductQuantizer::train (int n, const float * x)
 
 template<class PQEncoder>
 void compute_code(const ProductQuantizer& pq, const float *x, uint8_t *code) {
-  float distances [pq.ksub];
+  std::vector<float> distances(pq.ksub);
   PQEncoder encoder(code, pq.nbits);
   for (size_t m = 0; m < pq.M; m++) {
     float mindis = 1e20;
     uint64_t idxm = 0;
     const float * xsub = x + m * pq.dsub;
 
-    fvec_L2sqr_ny(distances, xsub, pq.get_centroids(m, 0), pq.dsub, pq.ksub);
+    fvec_L2sqr_ny(distances.data(), xsub, pq.get_centroids(m, 0), pq.dsub, pq.ksub);
 
     /* Find best centroid */
     for (size_t i = 0; i < pq.ksub; i++) {
@@ -496,7 +496,7 @@ void ProductQuantizer::compute_codes (const float * x,
     if (dsub < 16) { // simple direct computation
 
 #pragma omp parallel for
-        for (size_t i = 0; i < n; i++)
+        for (int64_t i = 0; i < n; i++)
             compute_code (x + i * d, codes + i * code_size);
 
     } else { // worthwile to use BLAS
@@ -505,7 +505,7 @@ void ProductQuantizer::compute_codes (const float * x,
         compute_distance_tables (n, x, dis_tables);
 
 #pragma omp parallel for
-        for (size_t i = 0; i < n; i++) {
+        for (int64_t i = 0; i < n; i++) {
             uint8_t * code = codes + i * code_size;
             const float * tab = dis_tables + i * ksub * M;
             compute_code_from_distance_table (tab, code);
@@ -552,7 +552,7 @@ void ProductQuantizer::compute_distance_tables (
     if (dsub < 16) {
 
 #pragma omp parallel for
-        for (size_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < nx; i++) {
             compute_distance_table (x + i * d, dis_tables + i * ksub * M);
         }
 
@@ -577,7 +577,7 @@ void ProductQuantizer::compute_inner_prod_tables (
     if (dsub < 16) {
 
 #pragma omp parallel for
-        for (size_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < nx; i++) {
             compute_inner_prod_table (x + i * d, dis_tables + i * ksub * M);
         }
 
@@ -614,7 +614,7 @@ static void pq_knn_search_with_tables (
 
 
 #pragma omp parallel for
-    for (size_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < nx; i++) {
         /* query preparation for asymmetric search: compute look-up tables */
         const float* dis_table = dis_tables + i * ksub * M;
 
@@ -728,7 +728,7 @@ void ProductQuantizer::search_sdc (const uint8_t * qcodes,
 
 
 #pragma omp parallel for
-    for (size_t i = 0; i < nq; i++) {
+    for (int64_t i = 0; i < nq; i++) {
 
         /* Compute distances and keep smallest values */
         idx_t * heap_ids = res->ids + i * k;

data/vendor/faiss/{impl → faiss/impl}/ScalarQuantizer.cpp

@@ -39,11 +39,7 @@ namespace faiss {
  * that hides the template mess.
  ********************************************************************/
 
-#ifdef __AVX__
-#define USE_AVX
-#endif
-
-#ifdef __F16C__
+#if defined(__F16C__) && defined(__AVX2__)
 #define USE_F16C
 #endif
 
@@ -72,7 +68,7 @@ struct Codec8bit {
         return (code[i] + 0.5f) / 255.0f;
     }
 
-#ifdef USE_AVX
+#ifdef __AVX2__
     static __m256 decode_8_components (const uint8_t *code, int i) {
         uint64_t c8 = *(uint64_t*)(code + i);
         __m128i c4lo = _mm_cvtepu8_epi32 (_mm_set1_epi32(c8));
@@ -101,7 +97,7 @@ struct Codec4bit {
     }
 
 
-#ifdef USE_AVX
+#ifdef __AVX2__
     static __m256 decode_8_components (const uint8_t *code, int i) {
         uint32_t c4 = *(uint32_t*)(code + (i >> 1));
         uint32_t mask = 0x0f0f0f0f;
@@ -169,18 +165,38 @@ struct Codec6bit {
         return (bits + 0.5f) / 63.0f;
     }
 
-#ifdef USE_AVX
+#ifdef __AVX2__
+
+    /* Load 6 bytes that represent 8 6-bit values, return them as a
+     * 8*32 bit vector register */
+    static __m256i load6 (const uint16_t *code16) {
+        const __m128i perm = _mm_set_epi8(-1, 5, 5, 4, 4, 3, -1, 3, -1, 2, 2, 1, 1, 0, -1, 0);
+        const __m256i shifts = _mm256_set_epi32(2, 4, 6, 0, 2, 4, 6, 0);
+
+        // load 6 bytes
+        __m128i c1 = _mm_set_epi16(0, 0, 0, 0, 0, code16[2], code16[1], code16[0]);
+
+        // put in 8 * 32 bits
+        __m128i c2 = _mm_shuffle_epi8(c1, perm);
+        __m256i c3 = _mm256_cvtepi16_epi32(c2);
+
+        // shift and mask out useless bits
+        __m256i c4 = _mm256_srlv_epi32(c3, shifts);
+        __m256i c5 = _mm256_and_si256(_mm256_set1_epi32(63), c4);
+        return c5;
+    }
+
     static __m256 decode_8_components (const uint8_t *code, int i) {
-        return _mm256_set_ps
-            (decode_component(code, i + 7),
-             decode_component(code, i + 6),
-             decode_component(code, i + 5),
-             decode_component(code, i + 4),
-             decode_component(code, i + 3),
-             decode_component(code, i + 2),
-             decode_component(code, i + 1),
-             decode_component(code, i + 0));
+        __m256i i8 = load6 ((const uint16_t *)(code + (i >> 2) * 3));
+        __m256 f8 = _mm256_cvtepi32_ps (i8);
+        // this could also be done with bit manipulations but it is
+        // not obviously faster
+        __m256 half = _mm256_set1_ps (0.5f);
+        f8 += half;
+        __m256 one_63 = _mm256_set1_ps (1.f / 63.f);
+        return f8 * one_63;
     }
+
 #endif
 };
 
@@ -326,12 +342,15 @@ struct QuantizerTemplate<Codec, true, 1>: ScalarQuantizer::Quantizer {
 
     void encode_vector(const float* x, uint8_t* code) const final {
         for (size_t i = 0; i < d; i++) {
-            float xi = (x[i] - vmin) / vdiff;
-            if (xi < 0) {
-                xi = 0;
-            }
-            if (xi > 1.0) {
-                xi = 1.0;
+            float xi = 0;
+            if (vdiff != 0) {
+                xi = (x[i] - vmin) / vdiff;
+                if (xi < 0) {
+                    xi = 0;
+                }
+                if (xi > 1.0) {
+                    xi = 1.0;
+                }
             }
             Codec::encode_component(xi, code, i);
         }
@@ -354,7 +373,7 @@ struct QuantizerTemplate<Codec, true, 1>: ScalarQuantizer::Quantizer {
 
 
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 
 template<class Codec>
 struct QuantizerTemplate<Codec, true, 8>: QuantizerTemplate<Codec, true, 1> {
@@ -384,11 +403,16 @@ struct QuantizerTemplate<Codec, false, 1>: ScalarQuantizer::Quantizer {
 
     void encode_vector(const float* x, uint8_t* code) const final {
         for (size_t i = 0; i < d; i++) {
-            float xi = (x[i] - vmin[i]) / vdiff[i];
-            if (xi < 0)
-                xi = 0;
-            if (xi > 1.0)
-                xi = 1.0;
+            float xi = 0;
+            if (vdiff[i] != 0) {
+                xi = (x[i] - vmin[i]) / vdiff[i];
+                if (xi < 0) {
+                    xi = 0;
+                }
+                if (xi > 1.0) {
+                    xi = 1.0;
+                }
+            }
             Codec::encode_component(xi, code, i);
         }
     }
@@ -409,7 +433,7 @@ struct QuantizerTemplate<Codec, false, 1>: ScalarQuantizer::Quantizer {
 };
 
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 
 template<class Codec>
 struct QuantizerTemplate<Codec, false, 8>: QuantizerTemplate<Codec, false, 1> {
@@ -513,7 +537,7 @@ struct Quantizer8bitDirect<1>: ScalarQuantizer::Quantizer {
 
 };
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 
 template<>
 struct Quantizer8bitDirect<8>: Quantizer8bitDirect<1> {
@@ -691,7 +715,7 @@ void train_NonUniform(RangeStat rs, float rs_arg,
             float vexp = (vmax[j] - vmin[j]) * rs_arg;
             vmin[j] -= vexp;
             vmax[j] += vexp;
-            vdiff [j] = vmax[j] - vmin[j];
+            vdiff[j] = vmax[j] - vmin[j];
         }
     } else {
         // transpose
@@ -704,7 +728,7 @@ void train_NonUniform(RangeStat rs, float rs_arg,
         }
         std::vector<float> trained_d(2);
 #pragma omp parallel for
-        for (size_t j = 0; j < d; j++) {
+        for (int j = 0; j < d; j++) {
             train_Uniform(rs, rs_arg,
                           n, k, xt.data() + j * n,
                           trained_d);
@@ -760,7 +784,7 @@ struct SimilarityL2<1> {
 };
 
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 template<>
 struct SimilarityL2<8> {
     static constexpr int simdwidth = 8;
@@ -835,7 +859,7 @@ struct SimilarityIP<1> {
     }
 };
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 
 template<>
 struct SimilarityIP<8> {
@@ -915,7 +939,7 @@ struct DCTemplate<Quantizer, Similarity, 1> : SQDistanceComputer
         for (size_t i = 0; i < quant.d; i++) {
             float x1 = quant.reconstruct_component(code1, i);
             float x2 = quant.reconstruct_component(code2, i);
-                sim.add_component_2(x1, x2);
+            sim.add_component_2(x1, x2);
         }
         return sim.result();
     }
@@ -1058,7 +1082,7 @@ struct DistanceComputerByte<Similarity, 1> : SQDistanceComputer {
 
 };
 
-#ifdef USE_AVX
+#ifdef __AVX2__
 
 
 template<class Similarity>
@@ -1298,7 +1322,7 @@ void ScalarQuantizer::compute_codes (const float * x,
 
     memset (codes, 0, code_size * n);
 #pragma omp parallel for
-    for (size_t i = 0; i < n; i++)
+    for (int64_t i = 0; i < n; i++)
         squant->encode_vector (x + i * d, codes + i * code_size);
 }
 
@@ -1307,7 +1331,7 @@ void ScalarQuantizer::decode (const uint8_t *codes, float *x, size_t n) const
     std::unique_ptr<Quantizer> squant(select_quantizer ());
 
 #pragma omp parallel for
-    for (size_t i = 0; i < n; i++)
+    for (int64_t i = 0; i < n; i++)
         squant->decode_vector (codes + i * code_size, x + i * d);
 }