faiss 0.4.1 → 0.4.2

data/vendor/faiss/faiss/impl/HNSW.cpp

@@ -15,8 +15,6 @@
 #include <faiss/impl/ResultHandler.h>
 #include <faiss/utils/prefetch.h>
 
-#include <faiss/impl/platform_macros.h>
-
 #ifdef __AVX2__
 #include <immintrin.h>
 
@@ -78,8 +76,9 @@ void HNSW::set_default_probas(int M, float levelMult) {
     cum_nneighbor_per_level.push_back(0);
     for (int level = 0;; level++) {
         float proba = exp(-level / levelMult) * (1 - exp(-1 / levelMult));
-        if (proba < 1e-9)
+        if (proba < 1e-9) {
             break;
+        }
         assign_probas.push_back(proba);
         nn += level == 0 ? M * 2 : M;
         cum_nneighbor_per_level.push_back(nn);
@@ -120,8 +119,9 @@ void HNSW::print_neighbor_stats(int level) const {
             neighbor_range(i, level, &begin, &end);
             std::unordered_set<int> neighset;
             for (size_t j = begin; j < end; j++) {
-                if (neighbors[j] < 0)
+                if (neighbors[j] < 0) {
                     break;
+                }
                 neighset.insert(neighbors[j]);
             }
             int n_neigh = neighset.size();
@@ -129,15 +129,17 @@ void HNSW::print_neighbor_stats(int level) const {
             int n_reciprocal = 0;
             for (size_t j = begin; j < end; j++) {
                 storage_idx_t i2 = neighbors[j];
-                if (i2 < 0)
+                if (i2 < 0) {
                     break;
+                }
                 FAISS_ASSERT(i2 != i);
                 size_t begin2, end2;
                 neighbor_range(i2, level, &begin2, &end2);
                 for (size_t j2 = begin2; j2 < end2; j2++) {
                     storage_idx_t i3 = neighbors[j2];
-                    if (i3 < 0)
+                    if (i3 < 0) {
                         break;
+                    }
                     if (i3 == i) {
                         n_reciprocal++;
                         continue;
@@ -178,8 +180,9 @@ void HNSW::fill_with_random_links(size_t n) {
         }
         printf("linking %zd elements in level %d\n", elts.size(), level);
 
-        if (elts.size() == 1)
+        if (elts.size() == 1) {
             continue;
+        }
 
         for (int ii = 0; ii < elts.size(); ii++) {
             int i = elts[ii];
@@ -213,8 +216,9 @@ int HNSW::prepare_level_tab(size_t n, bool preset_levels) {
     int max_level_2 = 0;
     for (int i = 0; i < n; i++) {
         int pt_level = levels[i + n0] - 1;
-        if (pt_level > max_level_2)
+        if (pt_level > max_level_2) {
             max_level_2 = pt_level;
+        }
         offsets.push_back(offsets.back() + cum_nb_neighbors(pt_level + 1));
     }
     neighbors.resize(offsets.back(), -1);
@@ -319,8 +323,9 @@ void add_link(
         // there is enough room, find a slot to add it
         size_t i = end;
         while (i > begin) {
-            if (hnsw.neighbors[i - 1] != -1)
+            if (hnsw.neighbors[i - 1] != -1) {
                 break;
+            }
             i--;
         }
         hnsw.neighbors[i] = dest;
@@ -397,10 +402,12 @@ void search_neighbors_to_add(
             // a reference version
             for (size_t i = begin; i < end; i++) {
                 storage_idx_t nodeId = hnsw.neighbors[i];
-                if (nodeId < 0)
+                if (nodeId < 0) {
                     break;
-                if (vt.get(nodeId))
+                }
+                if (vt.get(nodeId)) {
                     continue;
+                }
                 vt.set(nodeId);
 
                 float dis = qdis(nodeId);
@@ -436,8 +443,9 @@ void search_neighbors_to_add(
 
             for (size_t j = begin; j < end; j++) {
                 storage_idx_t nodeId = hnsw.neighbors[j];
-                if (nodeId < 0)
+                if (nodeId < 0) {
                     break;
+                }
                 if (vt.get(nodeId)) {
                     continue;
                 }
@@ -647,8 +655,9 @@ int search_from_candidates(
         size_t jmax = begin;
         for (size_t j = begin; j < end; j++) {
             int v1 = hnsw.neighbors[j];
-            if (v1 < 0)
+            if (v1 < 0) {
                 break;
+            }
 
             prefetch_L2(vt.visited.data() + v1);
             jmax += 1;
@@ -761,8 +770,9 @@ std::priority_queue<HNSW::Node> search_from_candidate_unbounded(
         size_t jmax = begin;
         for (size_t j = begin; j < end; j++) {
             int v1 = hnsw.neighbors[j];
-            if (v1 < 0)
+            if (v1 < 0) {
                 break;
+            }
 
             prefetch_L2(vt->visited.data() + v1);
             jmax += 1;
@@ -864,8 +874,9 @@ HNSWStats greedy_update_nearest(
 
         for (size_t j = begin; j < end; j++) {
             storage_idx_t v = hnsw.neighbors[j];
-            if (v < 0)
+            if (v < 0) {
                 break;
+            }
             ndis += 1;
 
             buffered_ids[n_buffered] = v;
@@ -1013,11 +1024,13 @@ void HNSW::search_level_0(
         for (int j = 0; j < nprobe; j++) {
             storage_idx_t cj = nearest_i[j];
 
-            if (cj < 0)
+            if (cj < 0) {
                 break;
+            }
 
-            if (vt.get(cj))
+            if (vt.get(cj)) {
                 continue;
+            }
 
             int candidates_size = std::max(efSearch, k);
             MinimaxHeap candidates(candidates_size);
@@ -1044,8 +1057,9 @@ void HNSW::search_level_0(
         for (int j = 0; j < nprobe; j++) {
             storage_idx_t cj = nearest_i[j];
 
-            if (cj < 0)
+            if (cj < 0) {
                 break;
+            }
             candidates.push(cj, nearest_d[j]);
         }
 
@@ -1093,8 +1107,9 @@ void HNSW::permute_entries(const idx_t* map) {
 
 void HNSW::MinimaxHeap::push(storage_idx_t i, float v) {
     if (k == n) {
-        if (v >= dis[0])
+        if (v >= dis[0]) {
             return;
+        }
         if (ids[0] != -1) {
             --nvalid;
         }

data/vendor/faiss/faiss/impl/IDSelector.cpp

@@ -71,8 +71,9 @@ IDSelectorArray::IDSelectorArray(size_t n, const idx_t* ids) : n(n), ids(ids) {}
 
 bool IDSelectorArray::is_member(idx_t id) const {
     for (idx_t i = 0; i < n; i++) {
-        if (ids[i] == id)
+        if (ids[i] == id) {
             return true;
+        }
     }
     return false;
 }

data/vendor/faiss/faiss/impl/LocalSearchQuantizer.cpp

@@ -14,17 +14,16 @@
 #include <random>
 
 #include <algorithm>
+#include <utility>
 
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/distances.h>
-#include <faiss/utils/hamming.h> // BitstringWriter
 #include <faiss/utils/utils.h>
 
 #include <faiss/utils/approx_topk/approx_topk.h>
 
 // this is needed for prefetching
-#include <faiss/impl/platform_macros.h>
 
 #ifdef __AVX2__
 #include <xmmintrin.h>
@@ -825,7 +824,7 @@ void LSQTimer::reset() {
 }
 
 LSQTimerScope::LSQTimerScope(LSQTimer* timer, std::string name)
-        : timer(timer), name(name), finished(false) {
+        : timer(timer), name(std::move(name)), finished(false) {
     t0 = getmillisecs();
 }
 

data/vendor/faiss/faiss/impl/NNDescent.cpp

@@ -55,11 +55,13 @@ Nhood::Nhood(const Nhood& other) {
 /// Insert a point into the candidate pool
 void Nhood::insert(int id, float dist) {
     LockGuard guard(lock);
-    if (dist > pool.front().distance)
+    if (dist > pool.front().distance) {
         return;
+    }
     for (int i = 0; i < pool.size(); i++) {
-        if (id == pool[i].id)
+        if (id == pool[i].id) {
             return;
+        }
     }
     if (pool.size() < pool.capacity()) {
         pool.push_back(Neighbor(id, dist, true));
@@ -118,22 +120,26 @@ int insert_into_pool(Neighbor* addr, int size, Neighbor nn) {
     }
     while (left < right - 1) {
         int mid = (left + right) / 2;
-        if (addr[mid].distance > nn.distance)
+        if (addr[mid].distance > nn.distance) {
             right = mid;
-        else
+        } else {
             left = mid;
+        }
     }
     // check equal ID
 
     while (left > 0) {
-        if (addr[left].distance < nn.distance)
+        if (addr[left].distance < nn.distance) {
             break;
-        if (addr[left].id == nn.id)
+        }
+        if (addr[left].id == nn.id) {
             return size + 1;
+        }
         left--;
     }
-    if (addr[left].id == nn.id || addr[right].id == nn.id)
+    if (addr[left].id == nn.id || addr[right].id == nn.id) {
         return size + 1;
+    }
     memmove((char*)&addr[right + 1],
             &addr[right],
             (size - right) * sizeof(Neighbor));
@@ -191,8 +197,9 @@ void NNDescent::update() {
         auto& nn = graph[n];
         std::sort(nn.pool.begin(), nn.pool.end());
 
-        if (nn.pool.size() > L)
+        if (nn.pool.size() > L) {
             nn.pool.resize(L);
+        }
         nn.pool.reserve(L); // keep the pool size be L
 
         int maxl = std::min(nn.M + S, (int)nn.pool.size());
@@ -470,8 +477,9 @@ void NNDescent::search(
                 Neighbor nn(id, dist, true);
                 int r = insert_into_pool(retset.data(), L_2, nn);
 
-                if (r < nk)
+                if (r < nk) {
                     nk = r;
+                }
             }
         }
         if (nk <= k) {

data/vendor/faiss/faiss/impl/PolysemousTraining.cpp

@@ -42,8 +42,9 @@ double PermutationObjective::cost_update(const int* perm, int iw, int jw)
     double orig_cost = compute_cost(perm);
 
     std::vector<int> perm2(n);
-    for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; i++) {
         perm2[i] = perm[i];
+    }
     perm2[iw] = perm[jw];
     perm2[jw] = perm[iw];
 
@@ -73,8 +74,9 @@ double SimulatedAnnealingOptimizer::run_optimization(int* best_perm) {
     // just do a few runs of the annealing and keep the lowest output cost
     for (int it = 0; it < n_redo; it++) {
         std::vector<int> perm(n);
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             perm[i] = i;
+        }
         if (init_random) {
             for (int i = 0; i < n; i++) {
                 int j = i + rnd->rand_int(n - i);
@@ -82,8 +84,9 @@ double SimulatedAnnealingOptimizer::run_optimization(int* best_perm) {
             }
         }
         float cost = optimize(perm.data());
-        if (logfile)
+        if (logfile) {
             fprintf(logfile, "\n");
+        }
         if (verbose > 1) {
             printf("    optimization run %d: cost=%g %s\n",
                    it,
@@ -103,8 +106,9 @@ double SimulatedAnnealingOptimizer::run_optimization(int* best_perm) {
 double SimulatedAnnealingOptimizer::optimize(int* perm) {
     double cost = init_cost = obj->compute_cost(perm);
     int log2n = 0;
-    while (!(n <= (1 << log2n)))
+    while (!(n <= (1 << log2n))) {
         log2n++;
+    }
     double temperature = init_temperature;
     int n_swap = 0, n_hot = 0;
     for (int it = 0; it < n_iter; it++) {
@@ -116,16 +120,18 @@ double SimulatedAnnealingOptimizer::optimize(int* perm) {
         } else {
             iw = rnd->rand_int(n);
             jw = rnd->rand_int(n - 1);
-            if (jw == iw)
+            if (jw == iw) {
                 jw++;
+            }
         }
         double delta_cost = obj->cost_update(perm, iw, jw);
         if (delta_cost < 0 || rnd->rand_float() < temperature) {
             std::swap(perm[iw], perm[jw]);
             cost += delta_cost;
             n_swap++;
-            if (delta_cost >= 0)
+            if (delta_cost >= 0) {
                 n_hot++;
+            }
         }
         if (verbose > 2 || (verbose > 1 && it % 10000 == 0)) {
             printf("      iteration %d cost %g temp %g n_swap %d "
@@ -147,8 +153,9 @@ double SimulatedAnnealingOptimizer::optimize(int* perm) {
                     n_hot);
         }
     }
-    if (verbose > 1)
+    if (verbose > 1) {
         printf("\n");
+    }
     return cost;
 }
 
@@ -467,8 +474,9 @@ struct Score3Computer : PermutationObjective {
      */
     Taccu compute_update(const int* perm, int iw, int jw) const {
         assert(iw != jw);
-        if (iw > jw)
+        if (iw > jw) {
             std::swap(iw, jw);
+        }
 
         Taccu accu = 0;
         const Ttab* n_gt_i = n_gt.data();
@@ -480,8 +488,9 @@ struct Score3Computer : PermutationObjective {
 
             accu += update_i_cross(perm, iw, jw, ip0, ip, n_gt_i);
 
-            if (ip != ip0)
+            if (ip != ip0) {
                 accu += update_i_plane(perm, iw, jw, ip0, ip, n_gt_i);
+            }
 
             n_gt_i += nc * nc;
         }
@@ -585,8 +594,9 @@ struct Score3Computer : PermutationObjective {
             const Ttab* n_gt_ij) const {
         Taccu accu = 0;
         for (int k = 0; k < nc; k++) {
-            if (k == iw || k == jw)
+            if (k == iw || k == jw) {
                 continue;
+            }
             int kp = perm[k];
             Ttab ng = n_gt_ij[k];
             if (hamming_dis(ip, jp) < hamming_dis(ip, kp)) {
@@ -617,8 +627,9 @@ struct Score3Computer : PermutationObjective {
             accu += update_k(perm, iw, jw, ip0, ip, jp0, jp, iw, n_gt_ij);
             accu += update_k(perm, iw, jw, ip0, ip, jp0, jp, jw, n_gt_ij);
 
-            if (jp != jp0)
+            if (jp != jp0) {
                 accu += update_j_line(perm, iw, jw, ip0, ip, jp0, jp, n_gt_ij);
+            }
 
             n_gt_ij += nc;
         }
@@ -721,8 +732,9 @@ struct RankingScore2 : Score3Computer<float, double> {
 
             { // build rank table
                 IndirectSort s = {gtd};
-                for (int j = 0; j < nb; j++)
+                for (int j = 0; j < nb; j++) {
                     ranks[j] = j;
+                }
                 std::sort(ranks, ranks + nb, s);
             }
 
@@ -814,17 +826,20 @@ void PolysemousTraining::optimize_reproduce_distances(
                    final_cost);
         }
 
-        if (log_pattern.size())
+        if (log_pattern.size()) {
             fclose(optim.logfile);
+        }
 
         std::vector<float> centroids_copy;
-        for (int i = 0; i < dsub * n; i++)
+        for (int i = 0; i < dsub * n; i++) {
             centroids_copy.push_back(centroids[i]);
+        }
 
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             memcpy(centroids + perm[i] * dsub,
                    centroids_copy.data() + i * dsub,
                    dsub * sizeof(centroids[0]));
+        }
     }
 }
 
@@ -853,14 +868,16 @@ void PolysemousTraining::optimize_ranking(
 
         if (n > 0) {
             std::vector<float> xtrain(n * dsub);
-            for (int i = 0; i < n; i++)
+            for (int i = 0; i < n; i++) {
                 memcpy(xtrain.data() + i * dsub,
                        x + i * pq.d + m * dsub,
                        sizeof(float) * dsub);
+            }
 
             codes.resize(n);
-            for (int i = 0; i < n; i++)
+            for (int i = 0; i < n; i++) {
                 codes[i] = all_codes[i * pq.code_size + m];
+            }
 
             nq = n / 4;
             nb = n - nq;
@@ -873,8 +890,9 @@ void PolysemousTraining::optimize_ranking(
         } else {
             nq = nb = pq.ksub;
             codes.resize(2 * nq);
-            for (int i = 0; i < nq; i++)
+            for (int i = 0; i < nq; i++) {
                 codes[i] = codes[i + nq] = i;
+            }
 
             gt_distances.resize(nq * nb);
 
@@ -921,19 +939,22 @@ void PolysemousTraining::optimize_ranking(
                optim.init_cost,
                final_cost);
 
-        if (log_pattern.size())
+        if (log_pattern.size()) {
             fclose(optim.logfile);
+        }
 
         float* centroids = pq.get_centroids(m, 0);
 
         std::vector<float> centroids_copy;
-        for (int i = 0; i < dsub * pq.ksub; i++)
+        for (int i = 0; i < dsub * pq.ksub; i++) {
             centroids_copy.push_back(centroids[i]);
+        }
 
-        for (int i = 0; i < pq.ksub; i++)
+        for (int i = 0; i < pq.ksub; i++) {
             memcpy(centroids + perm[i] * dsub,
                    centroids_copy.data() + i * dsub,
                    dsub * sizeof(centroids[0]));
+        }
     }
 }
 

data/vendor/faiss/faiss/impl/RaBitQuantizer.cpp

@@ -7,6 +7,9 @@
 
 #include <faiss/impl/RaBitQuantizer.h>
 
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/distances.h>
+#include <faiss/utils/rabitq_simd.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
@@ -14,9 +17,6 @@
 #include <memory>
 #include <vector>
 
-#include <faiss/impl/FaissAssert.h>
-#include <faiss/utils/distances.h>
-
 namespace faiss {
 
 struct FactorsData {
@@ -351,27 +351,9 @@ float RaBitDistanceComputerQ::distance_to_code(const uint8_t* code) {
     const size_t di_8b = (d + 7) / 8;
     const size_t di_64b = (di_8b / 8) * 8;
 
-    uint64_t dot_qo = 0;
-    for (size_t j = 0; j < qb; j++) {
-        const uint8_t* query_j = rearranged_rotated_qq.data() + j * di_8b;
-
-        // process 64-bit popcounts
-        uint64_t count_dot = 0;
-        for (size_t i = 0; i < di_64b; i += 8) {
-            const auto qv = *(const uint64_t*)(query_j + i);
-            const auto yv = *(const uint64_t*)(binary_data + i);
-            count_dot += __builtin_popcountll(qv & yv);
-        }
-
-        // process leftovers
-        for (size_t i = di_64b; i < di_8b; i++) {
-            const auto qv = *(query_j + i);
-            const auto yv = *(binary_data + i);
-            count_dot += __builtin_popcount(qv & yv);
-        }
-
-        dot_qo += (count_dot << j);
-    }
+    // Use the optimized popcount function from rabitq_simd.h
+    float dot_qo =
+            rabitq_dp_popcnt(rearranged_rotated_qq.data(), binary_data, d, qb);
 
     // It was a willful decision (after the discussion) to not to pre-cache
     //   the sum of all bits, just in order to reduce the overhead per vector.