faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/IndexBinaryHash.cpp

@@ -11,6 +11,7 @@
 
 #include <cinttypes>
 #include <cstdio>
+#include <memory>
 #include <unordered_set>
 
 #include <faiss/utils/hamming.h>
@@ -19,6 +20,16 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 
+#include <faiss/impl/simd_dispatch.h>
+
+// Scalar (NONE) fallback for dynamic dispatch
+#define THE_SIMD_LEVEL SIMDLevel::NONE
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/impl/binary_hamming/IndexBinaryHash_impl.h>
+#include <faiss/utils/hamming_distance/hamming_computer-generic.h>
+#undef THE_SIMD_LEVEL
+
 namespace faiss {
 
 void IndexBinaryHash::InvertedList::add(
@@ -29,8 +40,8 @@ void IndexBinaryHash::InvertedList::add(
     vecs.insert(vecs.end(), code, code + code_size);
 }
 
-IndexBinaryHash::IndexBinaryHash(int d, int b)
-        : IndexBinary(d), b(b), nflip(0) {
+IndexBinaryHash::IndexBinaryHash(int d_, int b_)
+        : IndexBinary(d_), b(b_), nflip(0) {
     is_trained = true;
 }
 
@@ -51,151 +62,20 @@ void IndexBinaryHash::add_with_ids(
         idx_t n,
         const uint8_t* x,
         const idx_t* xids) {
-    uint64_t mask = ((uint64_t)1 << b) - 1;
     // simplistic add function. Cannot really be parallelized.
 
     for (idx_t i = 0; i < n; i++) {
         idx_t id = xids ? xids[i] : ntotal + i;
         const uint8_t* xi = x + i * code_size;
-        idx_t hash = *((uint64_t*)xi) & mask;
+        BitstringReader br(xi, code_size);
+        idx_t hash = br.read(b);
         invlists[hash].add(id, code_size, xi);
     }
     ntotal += n;
 }
 
-namespace {
-
-/** Enumerate all bit vectors of size nbit with up to maxflip 1s
- * test in P127257851 P127258235
- */
-struct FlipEnumerator {
-    int nbit, nflip, maxflip;
-    uint64_t mask, x;
-
-    FlipEnumerator(int nbit, int maxflip) : nbit(nbit), maxflip(maxflip) {
-        nflip = 0;
-        mask = 0;
-        x = 0;
-    }
-
-    bool next() {
-        if (x == mask) {
-            if (nflip == maxflip) {
-                return false;
-            }
-            // increase Hamming radius
-            nflip++;
-            mask = (((uint64_t)1 << nflip) - 1);
-            x = mask << (nbit - nflip);
-            return true;
-        }
-
-        int i = __builtin_ctzll(x);
-
-        if (i > 0) {
-            x ^= (uint64_t)3 << (i - 1);
-        } else {
-            // nb of LSB 1s
-            int n1 = __builtin_ctzll(~x);
-            // clear them
-            x &= ((uint64_t)(-1) << n1);
-            int n2 = __builtin_ctzll(x);
-            x ^= (((uint64_t)1 << (n1 + 2)) - 1) << (n2 - n1 - 1);
-        }
-        return true;
-    }
-};
-
-struct RangeSearchResults {
-    int radius;
-    RangeQueryResult& qres;
-
-    inline void add(float dis, idx_t id) {
-        if (dis < radius) {
-            qres.add(dis, id);
-        }
-    }
-};
-
-struct KnnSearchResults {
-    // heap params
-    idx_t k;
-    int32_t* heap_sim;
-    idx_t* heap_ids;
-
-    using C = CMax<int, idx_t>;
-
-    inline void add(float dis, idx_t id) {
-        if (dis < heap_sim[0]) {
-            heap_replace_top<C>(k, heap_sim, heap_ids, dis, id);
-        }
-    }
-};
-
-template <class HammingComputer, class SearchResults>
-void search_single_query_template(
-        const IndexBinaryHash& index,
-        const uint8_t* q,
-        SearchResults& res,
-        size_t& n0,
-        size_t& nlist,
-        size_t& ndis) {
-    size_t code_size = index.code_size;
-    uint64_t mask = ((uint64_t)1 << index.b) - 1;
-    uint64_t qhash = *((uint64_t*)q) & mask;
-    HammingComputer hc(q, code_size);
-    FlipEnumerator fe(index.b, index.nflip);
-
-    // loop over neighbors that are at most at nflip bits
-    do {
-        uint64_t hash = qhash ^ fe.x;
-        auto it = index.invlists.find(hash);
-
-        if (it == index.invlists.end()) {
-            continue;
-        }
-
-        const IndexBinaryHash::InvertedList& il = it->second;
-
-        size_t nv = il.ids.size();
-
-        if (nv == 0) {
-            n0++;
-        } else {
-            const uint8_t* codes = il.vecs.data();
-            for (size_t i = 0; i < nv; i++) {
-                int dis = hc.hamming(codes);
-                res.add(dis, il.ids[i]);
-                codes += code_size;
-            }
-            ndis += nv;
-            nlist++;
-        }
-    } while (fe.next());
-}
-
-struct Run_search_single_query {
-    using T = void;
-    template <class HammingComputer, class... Types>
-    T f(Types*... args) {
-        search_single_query_template<HammingComputer>(*args...);
-    }
-};
-
-template <class SearchResults>
-void search_single_query(
-        const IndexBinaryHash& index,
-        const uint8_t* q,
-        SearchResults& res,
-        size_t& n0,
-        size_t& nlist,
-        size_t& ndis) {
-    Run_search_single_query r;
-    dispatch_HammingComputer(
-            index.code_size, r, &index, &q, &res, &n0, &nlist, &ndis);
-}
-
-} // anonymous namespace
+// search_single_query_template and helpers are now in
+// impl/binary_hamming/IndexBinaryHash_impl.h (compiled per-ISA)
 
 void IndexBinaryHash::range_search(
         idx_t n,
@@ -214,10 +94,12 @@ void IndexBinaryHash::range_search(
 #pragma omp for
         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;
 
-            search_single_query(*this, q, res, n0, nlist, ndis);
+            with_simd_level([&]<SIMDLevel SL>() {
+                binary_hash_range_search_fixSL<SL>(
+                        *this, q, radius, qres, n0, nlist, ndis);
+            });
         }
         pres.finalize();
     }
@@ -247,10 +129,12 @@ void IndexBinaryHash::search(
         idx_t* idxi = labels + k * i;
 
         heap_heapify<HeapForL2>(k, simi, idxi);
-        KnnSearchResults res = {k, simi, idxi};
         const uint8_t* q = x + i * code_size;
 
-        search_single_query(*this, q, res, n0, nlist, ndis);
+        with_simd_level([&]<SIMDLevel SL>() {
+            binary_hash_knn_search_fixSL<SL>(
+                    *this, q, k, simi, idxi, n0, nlist, ndis);
+        });
 
         heap_reorder<HeapForL2>(k, simi, idxi);
     }
@@ -285,19 +169,15 @@ IndexBinaryHashStats indexBinaryHash_stats;
  * IndexBinaryMultiHash implementation
  ******************************************************/
 
-IndexBinaryMultiHash::IndexBinaryMultiHash(int d, int nhash, int b)
-        : IndexBinary(d),
-          storage(new IndexBinaryFlat(d)),
-          own_fields(true),
-          maps(nhash),
-          nhash(nhash),
-          b(b),
-          nflip(0) {
-    FAISS_THROW_IF_NOT(nhash * b <= d);
+IndexBinaryMultiHash::IndexBinaryMultiHash(int d_, int nhash_, int b_)
+        : IndexBinary(d_), maps(nhash_), nhash(nhash_), b(b_), nflip(0) {
+    FAISS_THROW_IF_NOT(nhash_ * b_ <= d_);
+    storage = std::make_unique<IndexBinaryFlat>(d_).release();
+    own_fields = true;
 }
 
 IndexBinaryMultiHash::IndexBinaryMultiHash()
-        : storage(nullptr), own_fields(true), nhash(0), b(0), nflip(0) {}
+        : storage(nullptr), nhash(0), b(0), nflip(0) {}
 
 IndexBinaryMultiHash::~IndexBinaryMultiHash() {
     if (own_fields) {
@@ -308,7 +188,7 @@ IndexBinaryMultiHash::~IndexBinaryMultiHash() {
 void IndexBinaryMultiHash::reset() {
     storage->reset();
     ntotal = 0;
-    for (auto map : maps) {
+    for (auto& map : maps) {
         map.clear();
     }
 }
@@ -316,94 +196,19 @@ void IndexBinaryMultiHash::reset() {
 void IndexBinaryMultiHash::add(idx_t n, const uint8_t* x) {
     storage->add(n, x);
     // populate maps
-    uint64_t mask = ((uint64_t)1 << b) - 1;
-
     for (idx_t i = 0; i < n; i++) {
         const uint8_t* xi = x + i * code_size;
-        int ho = 0;
+        BitstringReader br(xi, code_size);
         for (int h = 0; h < nhash; h++) {
-            uint64_t hash = *(uint64_t*)(xi + (ho >> 3)) >> (ho & 7);
-            hash &= mask;
+            uint64_t hash = br.read(b);
             maps[h][hash].push_back(i + ntotal);
-            ho += b;
         }
     }
     ntotal += n;
 }
 
-namespace {
-
-template <class HammingComputer, class SearchResults>
-static void verify_shortlist(
-        const IndexBinaryFlat* index,
-        const uint8_t* q,
-        const std::unordered_set<idx_t>& shortlist,
-        SearchResults& res) {
-    size_t code_size = index->code_size;
-
-    HammingComputer hc(q, code_size);
-    const uint8_t* codes = index->xb.data();
-
-    for (auto i : shortlist) {
-        int dis = hc.hamming(codes + i * code_size);
-        res.add(dis, i);
-    }
-}
-
-struct Run_verify_shortlist {
-    using T = void;
-    template <class HammingComputer, class... Types>
-    void f(Types... args) {
-        verify_shortlist<HammingComputer>(args...);
-    }
-};
-
-template <class SearchResults>
-void search_1_query_multihash(
-        const IndexBinaryMultiHash& index,
-        const uint8_t* xi,
-        SearchResults& res,
-        size_t& n0,
-        size_t& nlist,
-        size_t& ndis) {
-    std::unordered_set<idx_t> shortlist;
-    int b = index.b;
-    uint64_t mask = ((uint64_t)1 << b) - 1;
-
-    int ho = 0;
-    for (int h = 0; h < index.nhash; h++) {
-        uint64_t qhash = *(uint64_t*)(xi + (ho >> 3)) >> (ho & 7);
-        qhash &= mask;
-        const IndexBinaryMultiHash::Map& map = index.maps[h];
-
-        FlipEnumerator fe(index.b, index.nflip);
-        // loop over neighbors that are at most at nflip bits
-        do {
-            uint64_t hash = qhash ^ fe.x;
-            auto it = map.find(hash);
-
-            if (it != map.end()) {
-                const std::vector<idx_t>& v = it->second;
-                for (auto i : v) {
-                    shortlist.insert(i);
-                }
-                nlist++;
-            } else {
-                n0++;
-            }
-        } while (fe.next());
-
-        ho += b;
-    }
-    ndis += shortlist.size();
-
-    // verify shortlist
-    Run_verify_shortlist r;
-    dispatch_HammingComputer(
-            index.code_size, r, index.storage, xi, shortlist, res);
-}
-
-} // anonymous namespace
+// verify_shortlist and search_1_query_multihash are now in
+// impl/binary_hamming/IndexBinaryHash_impl.h (compiled per-ISA)
 
 void IndexBinaryMultiHash::range_search(
         idx_t n,
@@ -422,10 +227,12 @@ void IndexBinaryMultiHash::range_search(
 #pragma omp for
         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;
 
-            search_1_query_multihash(*this, q, res, n0, nlist, ndis);
+            with_simd_level([&]<SIMDLevel SL>() {
+                binary_multihash_range_search_fixSL<SL>(
+                        *this, q, radius, qres, n0, nlist, ndis);
+            });
         }
         pres.finalize();
     }
@@ -455,10 +262,12 @@ void IndexBinaryMultiHash::search(
         idx_t* idxi = labels + k * i;
 
         heap_heapify<HeapForL2>(k, simi, idxi);
-        KnnSearchResults res = {k, simi, idxi};
         const uint8_t* q = x + i * code_size;
 
-        search_1_query_multihash(*this, q, res, n0, nlist, ndis);
+        with_simd_level([&]<SIMDLevel SL>() {
+            binary_multihash_knn_search_fixSL<SL>(
+                    *this, q, k, simi, idxi, n0, nlist, ndis);
+        });
 
         heap_reorder<HeapForL2>(k, simi, idxi);
     }
@@ -470,7 +279,7 @@ void IndexBinaryMultiHash::search(
 
 size_t IndexBinaryMultiHash::hashtable_size() const {
     size_t tot = 0;
-    for (auto map : maps) {
+    for (const auto& map : maps) {
         tot += map.size();
     }
 

data/vendor/faiss/faiss/IndexBinaryHash.h

@@ -66,10 +66,10 @@ struct IndexBinaryHash : IndexBinary {
 };
 
 struct IndexBinaryHashStats {
-    size_t nq;     // nb of queries run
-    size_t n0;     // nb of empty lists
-    size_t nlist;  // nb of non-empty inverted lists scanned
-    size_t ndis{}; // nb of distances computed
+    size_t nq = 0;    // nb of queries run
+    size_t n0 = 0;    // nb of empty lists
+    size_t nlist = 0; // nb of non-empty inverted lists scanned
+    size_t ndis = 0;  // nb of distances computed
 
     IndexBinaryHashStats() {
         reset();
@@ -82,8 +82,8 @@ FAISS_API extern IndexBinaryHashStats indexBinaryHash_stats;
 /** just uses the b first bits as a hash value */
 struct IndexBinaryMultiHash : IndexBinary {
     // where the vectors are actually stored
-    IndexBinaryFlat* storage;
-    bool own_fields;
+    IndexBinaryFlat* storage = nullptr;
+    bool own_fields = false;
 
     // maps hash values to the ids that hash to them
     using Map = std::unordered_map<idx_t, std::vector<idx_t>>;