faiss 0.3.0 → 0.3.1

data/vendor/faiss/faiss/IndexPQ.cpp

@@ -14,6 +14,7 @@
 #include <cstring>
 
 #include <algorithm>
+#include <memory>
 
 #include <faiss/impl/DistanceComputer.h>
 #include <faiss/impl/FaissAssert.h>
@@ -86,7 +87,7 @@ struct PQDistanceComputer : FlatCodesDistanceComputer {
         ndis++;
 
         float dis = distance_single_code<PQDecoder>(
-                pq, precomputed_table.data(), code);
+                pq.M, pq.nbits, precomputed_table.data(), code);
         return dis;
     }
 
@@ -198,17 +199,16 @@ void IndexPQ::search(
 
     } else { // code-to-code distances
 
-        uint8_t* q_codes = new uint8_t[n * pq.code_size];
-        ScopeDeleter<uint8_t> del(q_codes);
+        std::unique_ptr<uint8_t[]> q_codes(new uint8_t[n * pq.code_size]);
 
         if (!encode_signs) {
-            pq.compute_codes(x, q_codes, n);
+            pq.compute_codes(x, q_codes.get(), n);
         } else {
             FAISS_THROW_IF_NOT(d == pq.nbits * pq.M);
-            memset(q_codes, 0, n * pq.code_size);
+            memset(q_codes.get(), 0, n * pq.code_size);
             for (size_t i = 0; i < n; i++) {
                 const float* xi = x + i * d;
-                uint8_t* code = q_codes + i * pq.code_size;
+                uint8_t* code = q_codes.get() + i * pq.code_size;
                 for (int j = 0; j < d; j++)
                     if (xi[j] > 0)
                         code[j >> 3] |= 1 << (j & 7);
@@ -219,19 +219,18 @@ void IndexPQ::search(
             float_maxheap_array_t res = {
                     size_t(n), size_t(k), labels, distances};
 
-            pq.search_sdc(q_codes, n, codes.data(), ntotal, &res, true);
+            pq.search_sdc(q_codes.get(), n, codes.data(), ntotal, &res, true);
 
         } else {
-            int* idistances = new int[n * k];
-            ScopeDeleter<int> del(idistances);
+            std::unique_ptr<int[]> idistances(new int[n * k]);
 
             int_maxheap_array_t res = {
-                    size_t(n), size_t(k), labels, idistances};
+                    size_t(n), size_t(k), labels, idistances.get()};
 
             if (search_type == ST_HE) {
                 hammings_knn_hc(
                         &res,
-                        q_codes,
+                        q_codes.get(),
                         codes.data(),
                         ntotal,
                         pq.code_size,
@@ -240,7 +239,7 @@ void IndexPQ::search(
             } else if (search_type == ST_generalized_HE) {
                 generalized_hammings_knn_hc(
                         &res,
-                        q_codes,
+                        q_codes.get(),
                         codes.data(),
                         ntotal,
                         pq.code_size,
@@ -263,21 +262,23 @@ void IndexPQStats::reset() {
 
 IndexPQStats indexPQ_stats;
 
+namespace {
+
 template <class HammingComputer>
-static size_t polysemous_inner_loop(
-        const IndexPQ& index,
+size_t polysemous_inner_loop(
+        const IndexPQ* index,
         const float* dis_table_qi,
         const uint8_t* q_code,
         size_t k,
         float* heap_dis,
         int64_t* heap_ids,
         int ht) {
-    int M = index.pq.M;
-    int code_size = index.pq.code_size;
-    int ksub = index.pq.ksub;
-    size_t ntotal = index.ntotal;
+    int M = index->pq.M;
+    int code_size = index->pq.code_size;
+    int ksub = index->pq.ksub;
+    size_t ntotal = index->ntotal;
 
-    const uint8_t* b_code = index.codes.data();
+    const uint8_t* b_code = index->codes.data();
 
     size_t n_pass_i = 0;
 
@@ -305,6 +306,16 @@ static size_t polysemous_inner_loop(
     return n_pass_i;
 }
 
+struct Run_polysemous_inner_loop {
+    using T = size_t;
+    template <class HammingComputer, class... Types>
+    size_t f(Types... args) {
+        return polysemous_inner_loop<HammingComputer>(args...);
+    }
+};
+
+} // anonymous namespace
+
 void IndexPQ::search_core_polysemous(
         idx_t n,
         const float* x,
@@ -321,22 +332,20 @@ void IndexPQ::search_core_polysemous(
     }
 
     // PQ distance tables
-    float* dis_tables = new float[n * pq.ksub * pq.M];
-    ScopeDeleter<float> del(dis_tables);
-    pq.compute_distance_tables(n, x, dis_tables);
+    std::unique_ptr<float[]> dis_tables(new float[n * pq.ksub * pq.M]);
+    pq.compute_distance_tables(n, x, dis_tables.get());
 
     // Hamming embedding queries
-    uint8_t* q_codes = new uint8_t[n * pq.code_size];
-    ScopeDeleter<uint8_t> del2(q_codes);
+    std::unique_ptr<uint8_t[]> q_codes(new uint8_t[n * pq.code_size]);
 
     if (false) {
-        pq.compute_codes(x, q_codes, n);
+        pq.compute_codes(x, q_codes.get(), n);
     } else {
 #pragma omp parallel for
         for (idx_t qi = 0; qi < n; qi++) {
             pq.compute_code_from_distance_table(
-                    dis_tables + qi * pq.M * pq.ksub,
-                    q_codes + qi * pq.code_size);
+                    dis_tables.get() + qi * pq.M * pq.ksub,
+                    q_codes.get() + qi * pq.code_size);
         }
     }
 
@@ -346,54 +355,33 @@ void IndexPQ::search_core_polysemous(
 
 #pragma omp parallel for reduction(+ : n_pass, bad_code_size)
     for (idx_t qi = 0; qi < n; qi++) {
-        const uint8_t* q_code = q_codes + qi * pq.code_size;
+        const uint8_t* q_code = q_codes.get() + qi * pq.code_size;
 
-        const float* dis_table_qi = dis_tables + qi * pq.M * pq.ksub;
+        const float* dis_table_qi = dis_tables.get() + qi * pq.M * pq.ksub;
 
         int64_t* heap_ids = labels + qi * k;
         float* heap_dis = distances + qi * k;
         maxheap_heapify(k, heap_dis, heap_ids);
 
         if (!generalized_hamming) {
-            switch (pq.code_size) {
-#define DISPATCH(cs)                                          \
-    case cs:                                                  \
-        n_pass += polysemous_inner_loop<HammingComputer##cs>( \
-                *this,                                        \
-                dis_table_qi,                                 \
-                q_code,                                       \
-                k,                                            \
-                heap_dis,                                     \
-                heap_ids,                                     \
-                polysemous_ht);                               \
-        break;
-                DISPATCH(4)
-                DISPATCH(8)
-                DISPATCH(16)
-                DISPATCH(32)
-                DISPATCH(20)
-                default:
-                    if (pq.code_size % 4 == 0) {
-                        n_pass += polysemous_inner_loop<HammingComputerDefault>(
-                                *this,
-                                dis_table_qi,
-                                q_code,
-                                k,
-                                heap_dis,
-                                heap_ids,
-                                polysemous_ht);
-                    } else {
-                        bad_code_size++;
-                    }
-                    break;
-            }
-#undef DISPATCH
+            Run_polysemous_inner_loop r;
+            n_pass += dispatch_HammingComputer(
+                    pq.code_size,
+                    r,
+                    this,
+                    dis_table_qi,
+                    q_code,
+                    k,
+                    heap_dis,
+                    heap_ids,
+                    polysemous_ht);
+
         } else { // generalized hamming
             switch (pq.code_size) {
 #define DISPATCH(cs)                                             \
     case cs:                                                     \
         n_pass += polysemous_inner_loop<GenHammingComputer##cs>( \
-                *this,                                           \
+                this,                                            \
                 dis_table_qi,                                    \
                 q_code,                                          \
                 k,                                               \
@@ -407,7 +395,7 @@ void IndexPQ::search_core_polysemous(
                 default:
                     if (pq.code_size % 8 == 0) {
                         n_pass += polysemous_inner_loop<GenHammingComputerM8>(
-                                *this,
+                                this,
                                 dis_table_qi,
                                 q_code,
                                 k,
@@ -450,12 +438,11 @@ void IndexPQ::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
 
 void IndexPQ::hamming_distance_table(idx_t n, const float* x, int32_t* dis)
         const {
-    uint8_t* q_codes = new uint8_t[n * pq.code_size];
-    ScopeDeleter<uint8_t> del(q_codes);
+    std::unique_ptr<uint8_t[]> q_codes(new uint8_t[n * pq.code_size]);
 
-    pq.compute_codes(x, q_codes, n);
+    pq.compute_codes(x, q_codes.get(), n);
 
-    hammings(q_codes, codes.data(), n, ntotal, pq.code_size, dis);
+    hammings(q_codes.get(), codes.data(), n, ntotal, pq.code_size, dis);
 }
 
 void IndexPQ::hamming_distance_histogram(
@@ -469,16 +456,15 @@ void IndexPQ::hamming_distance_histogram(
     FAISS_THROW_IF_NOT(pq.nbits == 8);
 
     // Hamming embedding queries
-    uint8_t* q_codes = new uint8_t[n * pq.code_size];
-    ScopeDeleter<uint8_t> del(q_codes);
-    pq.compute_codes(x, q_codes, n);
+    std::unique_ptr<uint8_t[]> q_codes(new uint8_t[n * pq.code_size]);
+    pq.compute_codes(x, q_codes.get(), n);
 
     uint8_t* b_codes;
-    ScopeDeleter<uint8_t> del_b_codes;
+    std::unique_ptr<uint8_t[]> del_b_codes;
 
     if (xb) {
         b_codes = new uint8_t[nb * pq.code_size];
-        del_b_codes.set(b_codes);
+        del_b_codes.reset(b_codes);
         pq.compute_codes(xb, b_codes, nb);
     } else {
         nb = ntotal;
@@ -491,8 +477,7 @@ void IndexPQ::hamming_distance_histogram(
 #pragma omp parallel
     {
         std::vector<int64_t> histi(nbits + 1);
-        hamdis_t* distances = new hamdis_t[nb * bs];
-        ScopeDeleter<hamdis_t> del(distances);
+        std::unique_ptr<hamdis_t[]> distances(new hamdis_t[nb * bs]);
 #pragma omp for
         for (idx_t q0 = 0; q0 < n; q0 += bs) {
             // printf ("dis stats: %zd/%zd\n", q0, n);
@@ -501,12 +486,12 @@ void IndexPQ::hamming_distance_histogram(
                 q1 = n;
 
             hammings(
-                    q_codes + q0 * pq.code_size,
+                    q_codes.get() + q0 * pq.code_size,
                     b_codes,
                     q1 - q0,
                     nb,
                     pq.code_size,
-                    distances);
+                    distances.get());
 
             for (size_t i = 0; i < nb * (q1 - q0); i++)
                 histi[distances[i]]++;
@@ -639,7 +624,7 @@ struct SemiSortedArray {
     int N;
 
     // type of the heap: CMax = sort ascending
-    typedef CMax<T, int> HC;
+    using HC = CMax<T, int>;
     std::vector<int> perm;
 
     int k; // k elements are sorted
@@ -733,7 +718,7 @@ struct MinSumK {
      * We use a heap to maintain a queue of sums, with the associated
      * terms involved in the sum.
      */
-    typedef CMin<T, int64_t> HC;
+    using HC = CMin<T, int64_t>;
     size_t heap_capacity, heap_size;
     T* bh_val;
     int64_t* bh_ids;
@@ -827,7 +812,7 @@ struct MinSumK {
             // enqueue followers
             int64_t ii = ti;
             for (int m = 0; m < M; m++) {
-                int64_t n = ii & ((1L << nbit) - 1);
+                int64_t n = ii & (((int64_t)1 << nbit) - 1);
                 ii >>= nbit;
                 if (n + 1 >= N)
                     continue;
@@ -851,7 +836,7 @@ struct MinSumK {
             }
             int64_t ti = 0;
             for (int m = 0; m < M; m++) {
-                int64_t n = ii & ((1L << nbit) - 1);
+                int64_t n = ii & (((int64_t)1 << nbit) - 1);
                 ti += int64_t(ssx[m].get_ord(n)) << (nbit * m);
                 ii >>= nbit;
             }
@@ -923,17 +908,16 @@ void MultiIndexQuantizer::search(
         return;
     }
 
-    float* dis_tables = new float[n * pq.ksub * pq.M];
-    ScopeDeleter<float> del(dis_tables);
+    std::unique_ptr<float[]> dis_tables(new float[n * pq.ksub * pq.M]);
 
-    pq.compute_distance_tables(n, x, dis_tables);
+    pq.compute_distance_tables(n, x, dis_tables.get());
 
     if (k == 1) {
         // simple version that just finds the min in each table
 
 #pragma omp parallel for
         for (int i = 0; i < n; i++) {
-            const float* dis_table = dis_tables + i * pq.ksub * pq.M;
+            const float* dis_table = dis_tables.get() + i * pq.ksub * pq.M;
             float dis = 0;
             idx_t label = 0;
 
@@ -963,7 +947,7 @@ void MultiIndexQuantizer::search(
                     k, pq.M, pq.nbits, pq.ksub);
 #pragma omp for
             for (int i = 0; i < n; i++) {
-                msk.run(dis_tables + i * pq.ksub * pq.M,
+                msk.run(dis_tables.get() + i * pq.ksub * pq.M,
                         pq.ksub,
                         distances + i * k,
                         labels + i * k);
@@ -975,7 +959,7 @@ void MultiIndexQuantizer::search(
 void MultiIndexQuantizer::reconstruct(idx_t key, float* recons) const {
     int64_t jj = key;
     for (int m = 0; m < pq.M; m++) {
-        int64_t n = jj & ((1L << pq.nbits) - 1);
+        int64_t n = jj & (((int64_t)1 << pq.nbits) - 1);
         jj >>= pq.nbits;
         memcpy(recons, pq.get_centroids(m, n), sizeof(recons[0]) * pq.dsub);
         recons += pq.dsub;
@@ -1107,7 +1091,7 @@ void MultiIndexQuantizer2::search(
 
                 const idx_t* idmap0 = sub_ids.data() + i * k2;
                 int64_t ld_idmap = k2 * n;
-                int64_t mask1 = ksub - 1L;
+                int64_t mask1 = ksub - (int64_t)1;
 
                 for (int k = 0; k < K; k++) {
                     const idx_t* idmap = idmap0;

data/vendor/faiss/faiss/IndexPQ.h

@@ -31,10 +31,7 @@ struct IndexPQ : IndexFlatCodes {
      * @param M      number of subquantizers
      * @param nbits  number of bit per subvector index
      */
-    IndexPQ(int d,        ///< dimensionality of the input vectors
-            size_t M,     ///< number of subquantizers
-            size_t nbits, ///< number of bit per subvector index
-            MetricType metric = METRIC_L2);
+    IndexPQ(int d, size_t M, size_t nbits, MetricType metric = METRIC_L2);
 
     IndexPQ();
 

data/vendor/faiss/faiss/IndexPQFastScan.cpp

@@ -7,8 +7,8 @@
 
 #include <faiss/IndexPQFastScan.h>
 
-#include <limits.h>
 #include <cassert>
+#include <climits>
 #include <memory>
 
 #include <omp.h>

data/vendor/faiss/faiss/IndexPreTransform.cpp

@@ -67,7 +67,7 @@ void IndexPreTransform::train(idx_t n, const float* x) {
         }
     }
     const float* prev_x = x;
-    ScopeDeleter<float> del;
+    std::unique_ptr<const float[]> del;
 
     if (verbose) {
         printf("IndexPreTransform::train: training chain 0 to %d\n",
@@ -102,10 +102,12 @@ void IndexPreTransform::train(idx_t n, const float* x) {
 
         float* xt = chain[i]->apply(n, prev_x);
 
-        if (prev_x != x)
-            delete[] prev_x;
+        if (prev_x != x) {
+            del.reset();
+        }
+
         prev_x = xt;
-        del.set(xt);
+        del.reset(xt);
     }
 
     is_trained = true;
@@ -113,11 +115,11 @@ void IndexPreTransform::train(idx_t n, const float* x) {
 
 const float* IndexPreTransform::apply_chain(idx_t n, const float* x) const {
     const float* prev_x = x;
-    ScopeDeleter<float> del;
+    std::unique_ptr<const float[]> del;
 
     for (int i = 0; i < chain.size(); i++) {
         float* xt = chain[i]->apply(n, prev_x);
-        ScopeDeleter<float> del2(xt);
+        std::unique_ptr<const float[]> del2(xt);
         del2.swap(del);
         prev_x = xt;
     }
@@ -128,11 +130,11 @@ const float* IndexPreTransform::apply_chain(idx_t n, const float* x) const {
 void IndexPreTransform::reverse_chain(idx_t n, const float* xt, float* x)
         const {
     const float* next_x = xt;
-    ScopeDeleter<float> del;
+    std::unique_ptr<const float[]> del;
 
     for (int i = chain.size() - 1; i >= 0; i--) {
         float* prev_x = (i == 0) ? x : new float[n * chain[i]->d_in];
-        ScopeDeleter<float> del2((prev_x == x) ? nullptr : prev_x);
+        std::unique_ptr<const float[]> del2((prev_x == x) ? nullptr : prev_x);
         chain[i]->reverse_transform(n, next_x, prev_x);
         del2.swap(del);
         next_x = prev_x;
@@ -141,9 +143,8 @@ void IndexPreTransform::reverse_chain(idx_t n, const float* xt, float* x)
 
 void IndexPreTransform::add(idx_t n, const float* x) {
     FAISS_THROW_IF_NOT(is_trained);
-    const float* xt = apply_chain(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
-    index->add(n, xt);
+    TransformedVectors tv(x, apply_chain(n, x));
+    index->add(n, tv.x);
     ntotal = index->ntotal;
 }
 
@@ -152,9 +153,8 @@ void IndexPreTransform::add_with_ids(
         const float* x,
         const idx_t* xids) {
     FAISS_THROW_IF_NOT(is_trained);
-    const float* xt = apply_chain(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
-    index->add_with_ids(n, xt, xids);
+    TransformedVectors tv(x, apply_chain(n, x));
+    index->add_with_ids(n, tv.x, xids);
     ntotal = index->ntotal;
 }
 
@@ -178,7 +178,7 @@ void IndexPreTransform::search(
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
     const float* xt = apply_chain(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
+    std::unique_ptr<const float[]> del(xt == x ? nullptr : xt);
     index->search(
             n, xt, k, distances, labels, extract_index_search_params(params));
 }
@@ -190,10 +190,9 @@ void IndexPreTransform::range_search(
         RangeSearchResult* result,
         const SearchParameters* params) const {
     FAISS_THROW_IF_NOT(is_trained);
-    const float* xt = apply_chain(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
+    TransformedVectors tv(x, apply_chain(n, x));
     index->range_search(
-            n, xt, radius, result, extract_index_search_params(params));
+            n, tv.x, radius, result, extract_index_search_params(params));
 }
 
 void IndexPreTransform::reset() {
@@ -209,7 +208,7 @@ size_t IndexPreTransform::remove_ids(const IDSelector& sel) {
 
 void IndexPreTransform::reconstruct(idx_t key, float* recons) const {
     float* x = chain.empty() ? recons : new float[index->d];
-    ScopeDeleter<float> del(recons == x ? nullptr : x);
+    std::unique_ptr<float[]> del(recons == x ? nullptr : x);
     // Initial reconstruction
     index->reconstruct(key, x);
 
@@ -219,7 +218,7 @@ void IndexPreTransform::reconstruct(idx_t key, float* recons) const {
 
 void IndexPreTransform::reconstruct_n(idx_t i0, idx_t ni, float* recons) const {
     float* x = chain.empty() ? recons : new float[ni * index->d];
-    ScopeDeleter<float> del(recons == x ? nullptr : x);
+    std::unique_ptr<float[]> del(recons == x ? nullptr : x);
     // Initial reconstruction
     index->reconstruct_n(i0, ni, x);
 
@@ -238,14 +237,14 @@ void IndexPreTransform::search_and_reconstruct(
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
 
-    const float* xt = apply_chain(n, x);
-    ScopeDeleter<float> del((xt == x) ? nullptr : xt);
+    TransformedVectors trans(x, apply_chain(n, x));
 
     float* recons_temp = chain.empty() ? recons : new float[n * k * index->d];
-    ScopeDeleter<float> del2((recons_temp == recons) ? nullptr : recons_temp);
+    std::unique_ptr<float[]> del2(
+            (recons_temp == recons) ? nullptr : recons_temp);
     index->search_and_reconstruct(
             n,
-            xt,
+            trans.x,
             k,
             distances,
             labels,
@@ -262,13 +261,8 @@ size_t IndexPreTransform::sa_code_size() const {
 
 void IndexPreTransform::sa_encode(idx_t n, const float* x, uint8_t* bytes)
         const {
-    if (chain.empty()) {
-        index->sa_encode(n, x, bytes);
-    } else {
-        const float* xt = apply_chain(n, x);
-        ScopeDeleter<float> del(xt == x ? nullptr : xt);
-        index->sa_encode(n, xt, bytes);
-    }
+    TransformedVectors tv(x, apply_chain(n, x));
+    index->sa_encode(n, tv.x, bytes);
 }
 
 void IndexPreTransform::sa_decode(idx_t n, const uint8_t* bytes, float* x)

data/vendor/faiss/faiss/IndexRefine.cpp

@@ -62,7 +62,7 @@ void IndexRefine::reset() {
 
 namespace {
 
-typedef faiss::idx_t idx_t;
+using idx_t = faiss::idx_t;
 
 template <class C>
 static void reorder_2_heaps(
@@ -96,25 +96,40 @@ void IndexRefine::search(
         idx_t k,
         float* distances,
         idx_t* labels,
-        const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+        const SearchParameters* params_in) const {
+    const IndexRefineSearchParameters* params = nullptr;
+    if (params_in) {
+        params = dynamic_cast<const IndexRefineSearchParameters*>(params_in);
+        FAISS_THROW_IF_NOT_MSG(
+                params, "IndexRefine params have incorrect type");
+    }
+
+    idx_t k_base = (params != nullptr) ? idx_t(k * params->k_factor)
+                                       : idx_t(k * k_factor);
+    SearchParameters* base_index_params =
+            (params != nullptr) ? params->base_index_params : nullptr;
+
+    FAISS_THROW_IF_NOT(k_base >= k);
+
+    FAISS_THROW_IF_NOT(base_index);
+    FAISS_THROW_IF_NOT(refine_index);
+
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
-    idx_t k_base = idx_t(k * k_factor);
     idx_t* base_labels = labels;
     float* base_distances = distances;
-    ScopeDeleter<idx_t> del1;
-    ScopeDeleter<float> del2;
+    std::unique_ptr<idx_t[]> del1;
+    std::unique_ptr<float[]> del2;
 
     if (k != k_base) {
         base_labels = new idx_t[n * k_base];
-        del1.set(base_labels);
+        del1.reset(base_labels);
         base_distances = new float[n * k_base];
-        del2.set(base_distances);
+        del2.reset(base_distances);
     }
 
-    base_index->search(n, x, k_base, base_distances, base_labels);
+    base_index->search(
+            n, x, k_base, base_distances, base_labels, base_index_params);
 
     for (int i = 0; i < n * k_base; i++)
         assert(base_labels[i] >= -1 && base_labels[i] < ntotal);
@@ -225,25 +240,40 @@ void IndexRefineFlat::search(
         idx_t k,
         float* distances,
         idx_t* labels,
-        const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+        const SearchParameters* params_in) const {
+    const IndexRefineSearchParameters* params = nullptr;
+    if (params_in) {
+        params = dynamic_cast<const IndexRefineSearchParameters*>(params_in);
+        FAISS_THROW_IF_NOT_MSG(
+                params, "IndexRefineFlat params have incorrect type");
+    }
+
+    idx_t k_base = (params != nullptr) ? idx_t(k * params->k_factor)
+                                       : idx_t(k * k_factor);
+    SearchParameters* base_index_params =
+            (params != nullptr) ? params->base_index_params : nullptr;
+
+    FAISS_THROW_IF_NOT(k_base >= k);
+
+    FAISS_THROW_IF_NOT(base_index);
+    FAISS_THROW_IF_NOT(refine_index);
+
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
-    idx_t k_base = idx_t(k * k_factor);
     idx_t* base_labels = labels;
     float* base_distances = distances;
-    ScopeDeleter<idx_t> del1;
-    ScopeDeleter<float> del2;
+    std::unique_ptr<idx_t[]> del1;
+    std::unique_ptr<float[]> del2;
 
     if (k != k_base) {
         base_labels = new idx_t[n * k_base];
-        del1.set(base_labels);
+        del1.reset(base_labels);
         base_distances = new float[n * k_base];
-        del2.set(base_distances);
+        del2.reset(base_distances);
     }
 
-    base_index->search(n, x, k_base, base_distances, base_labels);
+    base_index->search(
+            n, x, k_base, base_distances, base_labels, base_index_params);
 
     for (int i = 0; i < n * k_base; i++)
         assert(base_labels[i] >= -1 && base_labels[i] < ntotal);

data/vendor/faiss/faiss/IndexRefine.h

@@ -11,6 +11,13 @@
 
 namespace faiss {
 
+struct IndexRefineSearchParameters : SearchParameters {
+    float k_factor = 1;
+    SearchParameters* base_index_params = nullptr; // non-owning
+
+    virtual ~IndexRefineSearchParameters() = default;
+};
+
 /** Index that queries in a base_index (a fast one) and refines the
  *  results with an exact search, hopefully improving the results.
  */