diff --git a/faiss/impl/AuxIndexStructures.cpp b/faiss/impl/AuxIndexStructures.cpp index e1f77cde2..66aa2b94d 100644 --- a/faiss/impl/AuxIndexStructures.cpp +++ b/faiss/impl/AuxIndexStructures.cpp @@ -20,10 +20,11 @@ namespace faiss { * RangeSearchResult ***********************************************************************/ -RangeSearchResult::RangeSearchResult(size_t nq, bool alloc_lims) : nq(nq) { +RangeSearchResult::RangeSearchResult(size_t nq_in, bool alloc_lims) + : nq(nq_in) { if (alloc_lims) { - lims = new size_t[nq + 1]; - memset(lims, 0, sizeof(*lims) * (nq + 1)); + lims = new size_t[nq_in + 1]; + memset(lims, 0, sizeof(*lims) * (nq_in + 1)); } else { lims = nullptr; } @@ -39,7 +40,7 @@ void RangeSearchResult::do_allocation() { // simultaneously FAISS_THROW_IF_NOT(labels == nullptr && distances == nullptr); size_t ofs = 0; - for (int i = 0; i < nq; i++) { + for (size_t i = 0; i < nq; i++) { size_t n = lims[i]; lims[i] = ofs; ofs += n; @@ -59,12 +60,12 @@ RangeSearchResult::~RangeSearchResult() { * BufferList ***********************************************************************/ -BufferList::BufferList(size_t buffer_size) : buffer_size(buffer_size) { - wp = buffer_size; +BufferList::BufferList(size_t buffer_size_in) : buffer_size(buffer_size_in) { + wp = buffer_size_in; } BufferList::~BufferList() { - for (int i = 0; i < buffers.size(); i++) { + for (size_t i = 0; i < buffers.size(); i++) { delete[] buffers[i].ids; delete[] buffers[i].dis; } @@ -140,7 +141,7 @@ void RangeSearchPartialResult::finalize() { /// called by range_search before do_allocation void RangeSearchPartialResult::set_lims() { - for (int i = 0; i < queries.size(); i++) { + for (size_t i = 0; i < queries.size(); i++) { RangeQueryResult& qres = queries[i]; res->lims[qres.qno] = qres.nres; } @@ -149,7 +150,7 @@ void RangeSearchPartialResult::set_lims() { /// called by range_search after do_allocation void RangeSearchPartialResult::copy_result(bool incremental) { size_t ofs = 0; - for (int i = 0; i < queries.size(); i++) { + for (size_t i = 0; i < queries.size(); i++) { RangeQueryResult& qres = queries[i]; copy_range( diff --git a/faiss/impl/CodePacker.cpp b/faiss/impl/CodePacker.cpp index 9299ad1b2..618940887 100644 --- a/faiss/impl/CodePacker.cpp +++ b/faiss/impl/CodePacker.cpp @@ -33,10 +33,10 @@ void CodePacker::unpack_all(const uint8_t* block, uint8_t* flat_codes) const { * CodePackerFlat */ -CodePackerFlat::CodePackerFlat(size_t code_size) { - this->code_size = code_size; +CodePackerFlat::CodePackerFlat(size_t code_size_in) { + this->code_size = code_size_in; nvec = 1; - block_size = code_size; + block_size = code_size_in; } void CodePackerFlat::pack_all(const uint8_t* flat_codes, uint8_t* block) const { diff --git a/faiss/impl/IDSelector.cpp b/faiss/impl/IDSelector.cpp index d82562b34..9e029c07d 100644 --- a/faiss/impl/IDSelector.cpp +++ b/faiss/impl/IDSelector.cpp @@ -14,8 +14,11 @@ namespace faiss { * IDSelectorRange ***********************************************************************/ -IDSelectorRange::IDSelectorRange(idx_t imin, idx_t imax, bool assume_sorted) - : imin(imin), imax(imax), assume_sorted(assume_sorted) {} +IDSelectorRange::IDSelectorRange( + idx_t imin_in, + idx_t imax_in, + bool assume_sorted_in) + : imin(imin_in), imax(imax_in), assume_sorted(assume_sorted_in) {} bool IDSelectorRange::is_member(idx_t id) const { return id >= imin && id < imax; @@ -67,10 +70,11 @@ void IDSelectorRange::find_sorted_ids_bounds( * IDSelectorArray ***********************************************************************/ -IDSelectorArray::IDSelectorArray(size_t n, const idx_t* ids) : n(n), ids(ids) {} +IDSelectorArray::IDSelectorArray(size_t n_in, const idx_t* ids_in) + : n(n_in), ids(ids_in) {} bool IDSelectorArray::is_member(idx_t id) const { - for (idx_t i = 0; i < n; i++) { + for (size_t i = 0; i < n; i++) { if (ids[i] == id) { return true; } @@ -84,15 +88,15 @@ bool IDSelectorArray::is_member(idx_t id) const { IDSelectorBatch::IDSelectorBatch(size_t n, const idx_t* indices) { nbits = 0; - while (n > ((idx_t)1 << nbits)) { + while (n > (size_t{1} << nbits)) { nbits++; } nbits += 5; // for n = 1M, nbits = 25 is optimal, see P56659518 mask = ((idx_t)1 << nbits) - 1; - bloom.resize((idx_t)1 << (nbits - 3), 0); - for (idx_t i = 0; i < n; i++) { + bloom.resize(size_t{1} << (nbits - 3), 0); + for (size_t i = 0; i < n; i++) { idx_t id = indices[i]; set.insert(id); id &= mask; @@ -112,8 +116,8 @@ bool IDSelectorBatch::is_member(idx_t i) const { * IDSelectorBitmap ***********************************************************************/ -IDSelectorBitmap::IDSelectorBitmap(size_t n, const uint8_t* bitmap) - : n(n), bitmap(bitmap) {} +IDSelectorBitmap::IDSelectorBitmap(size_t n_in, const uint8_t* bitmap_in) + : n(n_in), bitmap(bitmap_in) {} bool IDSelectorBitmap::is_member(idx_t ii) const { uint64_t i = ii; diff --git a/faiss/impl/IDSelector.h b/faiss/impl/IDSelector.h index be7391520..631991bd1 100644 --- a/faiss/impl/IDSelector.h +++ b/faiss/impl/IDSelector.h @@ -116,7 +116,7 @@ struct IDSelectorBitmap : IDSelector { /** reverts the membership test of another selector */ struct IDSelectorNot : IDSelector { const IDSelector* sel; - explicit IDSelectorNot(const IDSelector* sel) : sel(sel) {} + explicit IDSelectorNot(const IDSelector* sel_) : sel(sel_) {} bool is_member(idx_t id) const final { return !sel->is_member(id); } @@ -125,7 +125,7 @@ struct IDSelectorNot : IDSelector { /// selects all entries (useful for benchmarking) struct IDSelectorAll : IDSelector { - bool is_member(idx_t id) const final { + bool is_member(idx_t /* id */) const final { return true; } virtual ~IDSelectorAll() {} @@ -136,8 +136,8 @@ struct IDSelectorAll : IDSelector { struct IDSelectorAnd : IDSelector { const IDSelector* lhs; const IDSelector* rhs; - IDSelectorAnd(const IDSelector* lhs, const IDSelector* rhs) - : lhs(lhs), rhs(rhs) {} + IDSelectorAnd(const IDSelector* lhs_, const IDSelector* rhs_) + : lhs(lhs_), rhs(rhs_) {} bool is_member(idx_t id) const final { return lhs->is_member(id) && rhs->is_member(id); } @@ -149,8 +149,8 @@ struct IDSelectorAnd : IDSelector { struct IDSelectorOr : IDSelector { const IDSelector* lhs; const IDSelector* rhs; - IDSelectorOr(const IDSelector* lhs, const IDSelector* rhs) - : lhs(lhs), rhs(rhs) {} + IDSelectorOr(const IDSelector* lhs_, const IDSelector* rhs_) + : lhs(lhs_), rhs(rhs_) {} bool is_member(idx_t id) const final { return lhs->is_member(id) || rhs->is_member(id); } @@ -162,8 +162,8 @@ struct IDSelectorOr : IDSelector { struct IDSelectorXOr : IDSelector { const IDSelector* lhs; const IDSelector* rhs; - IDSelectorXOr(const IDSelector* lhs, const IDSelector* rhs) - : lhs(lhs), rhs(rhs) {} + IDSelectorXOr(const IDSelector* lhs_, const IDSelector* rhs_) + : lhs(lhs_), rhs(rhs_) {} bool is_member(idx_t id) const final { return lhs->is_member(id) ^ rhs->is_member(id); } diff --git a/faiss/impl/PolysemousTraining.cpp b/faiss/impl/PolysemousTraining.cpp index a1408cd0c..9d61a6452 100644 --- a/faiss/impl/PolysemousTraining.cpp +++ b/faiss/impl/PolysemousTraining.cpp @@ -54,11 +54,11 @@ double PermutationObjective::cost_update(const int* perm, int iw, int jw) } SimulatedAnnealingOptimizer::SimulatedAnnealingOptimizer( - PermutationObjective* obj, + PermutationObjective* obj_in, const SimulatedAnnealingParameters& p) : SimulatedAnnealingParameters(p), - obj(obj), - n(obj->n), + obj(obj_in), + n(obj_in->n), logfile(nullptr) { rnd = new RandomGenerator(p.seed); FAISS_THROW_IF_NOT(n < 100000 && n >= 0); @@ -260,10 +260,10 @@ struct ReproduceWithHammingObjective : PermutationObjective { } ReproduceWithHammingObjective( - int nbits, + int nbits_in, const std::vector& dis_table, - double dis_weight_factor) - : nbits(nbits), dis_weight_factor(dis_weight_factor) { + double dis_weight_factor_in) + : nbits(nbits_in), dis_weight_factor(dis_weight_factor_in) { n = 1 << nbits; FAISS_THROW_IF_NOT(dis_table.size() == n * n); set_affine_target_dis(dis_table); @@ -373,12 +373,12 @@ double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw) } ReproduceDistancesObjective::ReproduceDistancesObjective( - int n, + int n_in, const double* source_dis_in, const double* target_dis_in, - double dis_weight_factor) - : dis_weight_factor(dis_weight_factor), target_dis(target_dis_in) { - this->n = n; + double dis_weight_factor_in) + : dis_weight_factor(dis_weight_factor_in), target_dis(target_dis_in) { + this->n = n_in; set_affine_target_dis(source_dis_in); } @@ -388,7 +388,7 @@ void ReproduceDistancesObjective::compute_mean_stdev( double* mean_out, double* stddev_out) { double sum = 0, sum2 = 0; - for (int i = 0; i < n2; i++) { + for (size_t i = 0; i < n2; i++) { sum += tab[i]; sum2 += tab[i] * tab[i]; } @@ -668,18 +668,18 @@ struct RankingScore2 : Score3Computer { const float* gt_distances; RankingScore2( - int nbits, - int nq, - int nb, - const uint32_t* qcodes, - const uint32_t* bcodes, - const float* gt_distances) - : nbits(nbits), - nq(nq), - nb(nb), - qcodes(qcodes), - bcodes(bcodes), - gt_distances(gt_distances) { + int nbits_in, + int nq_in, + int nb_in, + const uint32_t* qcodes_in, + const uint32_t* bcodes_in, + const float* gt_distances_in) + : nbits(nbits_in), + nq(nq_in), + nb(nb_in), + qcodes(qcodes_in), + bcodes(bcodes_in), + gt_distances(gt_distances_in) { n = nc = 1 << nbits; n_gt.resize(nc * nc * nc); init_n_gt(); @@ -796,7 +796,7 @@ void PolysemousTraining::optimize_reproduce_distances( } #pragma omp parallel for num_threads(nt) - for (int m = 0; m < pq.M; m++) { + for (int m = 0; m < static_cast(pq.M); m++) { std::vector dis_table; // printf ("Optimizing quantizer %d\n", m); @@ -823,7 +823,10 @@ void PolysemousTraining::optimize_reproduce_distances( if (log_pattern.size()) { char fname[256]; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" snprintf(fname, 256, log_pattern.c_str(), m); +#pragma GCC diagnostic pop printf("opening log file %s\n", fname); optim.logfile = fopen(fname, "w"); FAISS_THROW_IF_NOT_MSG(optim.logfile, "could not open logfile"); @@ -872,21 +875,21 @@ void PolysemousTraining::optimize_ranking( } #pragma omp parallel for - for (int m = 0; m < pq.M; m++) { + for (int m = 0; m < static_cast(pq.M); m++) { size_t nq, nb; std::vector codes; // query codes, then db codes std::vector gt_distances; // nq * nb matrix of distances if (n > 0) { std::vector xtrain(n * dsub); - for (int i = 0; i < n; i++) { + for (size_t 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 (size_t i = 0; i < n; i++) { codes[i] = all_codes[i * pq.code_size + m]; } @@ -901,8 +904,8 @@ void PolysemousTraining::optimize_ranking( } else { nq = nb = pq.ksub; codes.resize(2 * nq); - for (int i = 0; i < nq; i++) { - codes[i] = codes[i + nq] = i; + for (size_t i = 0; i < nq; i++) { + codes[i] = codes[i + nq] = static_cast(i); } gt_distances.resize(nq * nb); @@ -935,7 +938,10 @@ void PolysemousTraining::optimize_ranking( if (log_pattern.size()) { char fname[256]; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" snprintf(fname, 256, log_pattern.c_str(), m); +#pragma GCC diagnostic pop printf("opening log file %s\n", fname); optim.logfile = fopen(fname, "w"); FAISS_THROW_IF_NOT_FMT( @@ -957,11 +963,11 @@ void PolysemousTraining::optimize_ranking( float* centroids = pq.get_centroids(m, 0); std::vector centroids_copy; - for (int i = 0; i < dsub * pq.ksub; i++) { + for (size_t i = 0; i < dsub * pq.ksub; i++) { centroids_copy.push_back(centroids[i]); } - for (int i = 0; i < pq.ksub; i++) { + for (size_t i = 0; i < pq.ksub; i++) { memcpy(centroids + perm[i] * dsub, centroids_copy.data() + i * dsub, dsub * sizeof(centroids[0])); diff --git a/faiss/impl/PolysemousTraining.h b/faiss/impl/PolysemousTraining.h index cc9b76b28..45e5dc110 100644 --- a/faiss/impl/PolysemousTraining.h +++ b/faiss/impl/PolysemousTraining.h @@ -70,10 +70,10 @@ struct ReproduceDistancesObjective : PermutationObjective { double cost_update(const int* perm, int iw, int jw) const override; ReproduceDistancesObjective( - int n, + int n_in, const double* source_dis_in, const double* target_dis_in, - double dis_weight_factor); + double dis_weight_factor_in); static void compute_mean_stdev( const double* tab, @@ -95,7 +95,7 @@ struct SimulatedAnnealingOptimizer : SimulatedAnnealingParameters { FILE* logfile; /// logs values of the cost function SimulatedAnnealingOptimizer( - PermutationObjective* obj, + PermutationObjective* obj_in, const SimulatedAnnealingParameters& p); RandomGenerator* rnd; diff --git a/faiss/impl/ResultHandler.h b/faiss/impl/ResultHandler.h index ede8dc117..44b692ef8 100644 --- a/faiss/impl/ResultHandler.h +++ b/faiss/impl/ResultHandler.h @@ -66,8 +66,8 @@ struct BlockResultHandler { size_t nq; // number of queries for which we search const IDSelector* sel; - explicit BlockResultHandler(size_t nq, const IDSelector* sel = nullptr) - : nq(nq), sel(sel) { + explicit BlockResultHandler(size_t nq_, const IDSelector* sel_ = nullptr) + : nq(nq_), sel(sel_) { assert(!use_sel || sel); } @@ -108,10 +108,10 @@ struct SingleQueryBlockResultHandler : BlockResultHandler { ResultHandler& the_handler; explicit SingleQueryBlockResultHandler( - ResultHandler& the_handler, - const IDSelector* sel = nullptr) - : BlockResultHandler(1, sel), - the_handler(the_handler) {} + ResultHandler& the_handler_in, + const IDSelector* sel_in = nullptr) + : BlockResultHandler(1, sel_in), + the_handler(the_handler_in) {} struct SingleResultHandler : ResultHandlerT { ResultHandler& the_handler; @@ -121,9 +121,7 @@ struct SingleQueryBlockResultHandler : BlockResultHandler { : the_handler(hr.the_handler) {} /// begin results for query # i - void begin(const size_t qid) { - assert(qid == 0); - } + void begin(const size_t /* qid */) {} /// add one result for query i bool add_result(T dis, TI idx) final { @@ -149,15 +147,15 @@ struct TopkBlockResultHandler : BlockResultHandler { int64_t k; // number of results to keep TopkBlockResultHandler( - size_t nq, - T* dis_tab, - TI* ids_tab, - size_t k, - const IDSelector* sel = nullptr) - : BlockResultHandler(nq, sel), - dis_tab(dis_tab), - ids_tab(ids_tab), - k(k) {} + size_t nq_, + T* dis_tab_, + TI* ids_tab_, + size_t k_, + const IDSelector* sel_ = nullptr) + : BlockResultHandler(nq_, sel_), + dis_tab(dis_tab_), + ids_tab(ids_tab_), + k(k_) {} ~TopkBlockResultHandler() {} }; @@ -176,12 +174,16 @@ struct Top1BlockResultHandler : TopkBlockResultHandler { using BlockResultHandler::i1; Top1BlockResultHandler( - size_t nq, - T* dis_tab, - TI* ids_tab, - const IDSelector* sel = nullptr) - : TopkBlockResultHandler(nq, dis_tab, ids_tab, 1, sel) { - } + size_t nq_, + T* dis_tab_, + TI* ids_tab_, + const IDSelector* sel_ = nullptr) + : TopkBlockResultHandler( + nq_, + dis_tab_, + ids_tab_, + 1, + sel_) {} struct SingleResultHandler : ResultHandlerT { Top1BlockResultHandler& hr; @@ -190,7 +192,7 @@ struct Top1BlockResultHandler : TopkBlockResultHandler { TI min_idx; size_t current_idx = 0; - explicit SingleResultHandler(Top1BlockResultHandler& hr) : hr(hr) {} + explicit SingleResultHandler(Top1BlockResultHandler& hr_) : hr(hr_) {} /// begin results for query # i void begin(const size_t current_idx_2) { @@ -217,9 +219,9 @@ struct Top1BlockResultHandler : TopkBlockResultHandler { }; /// begin - void begin_multiple(size_t i0, size_t i1) final { - this->i0 = i0; - this->i1 = i1; + void begin_multiple(size_t i0_in, size_t i1_in) final { + this->i0 = i0_in; + this->i1 = i1_in; for (size_t i = i0; i < i1; i++) { this->dis_tab[i] = C::neutral(); @@ -228,7 +230,7 @@ struct Top1BlockResultHandler : TopkBlockResultHandler { /// add results for query i0..i1 and j0..j1 void add_results(size_t j0, size_t j1, const T* dis_tab_2) final { - for (int64_t i = i0; i < i1; i++) { + for (size_t i = i0; i < i1; i++) { const T* dis_tab_i = dis_tab_2 + (j1 - j0) * (i - i0) - j0; auto& min_distance = this->dis_tab[i]; @@ -270,8 +272,8 @@ struct HeapResultHandler : ResultHandlerT { T* heap_dis; TI* heap_ids; - HeapResultHandler(size_t k, T* heap_dis, TI* heap_ids) - : k(k), heap_dis(heap_dis), heap_ids(heap_ids) { + HeapResultHandler(size_t k_, T* heap_dis_, TI* heap_ids_) + : k(k_), heap_dis(heap_dis_), heap_ids(heap_ids_) { if (heap_dis) { this->threshold = heap_dis[0]; } @@ -297,13 +299,17 @@ struct HeapBlockResultHandler : TopkBlockResultHandler { using TopkBlockResultHandler::k; HeapBlockResultHandler( - size_t nq, - T* dis_tab, - TI* ids_tab, - size_t k, - const IDSelector* sel = nullptr) - : TopkBlockResultHandler(nq, dis_tab, ids_tab, k, sel) { - } + size_t nq_, + T* dis_tab_, + TI* ids_tab_, + size_t k_, + const IDSelector* sel_ = nullptr) + : TopkBlockResultHandler( + nq_, + dis_tab_, + ids_tab_, + k_, + sel_) {} /****************************************************** * API for 1 result at a time (each SingleResultHandler is @@ -313,9 +319,9 @@ struct HeapBlockResultHandler : TopkBlockResultHandler { struct SingleResultHandler : HeapResultHandler { HeapBlockResultHandler& hr; - explicit SingleResultHandler(HeapBlockResultHandler& hr) - : HeapResultHandler(hr.k, nullptr, nullptr), - hr(hr) {} + explicit SingleResultHandler(HeapBlockResultHandler& hr_) + : HeapResultHandler(hr_.k, nullptr, nullptr), + hr(hr_) {} /// begin results for query # i void begin(size_t i) { @@ -346,12 +352,14 @@ struct HeapBlockResultHandler : TopkBlockResultHandler { } /// add results for query i0..i1 and j0..j1 - void add_results(size_t j0, size_t j1, const T* dis_tab) final { + void add_results(size_t j0, size_t j1, const T* dis_in) final { #pragma omp parallel for - for (int64_t i = i0; i < i1; i++) { + for (int64_t i = static_cast(i0); i < static_cast(i1); + i++) { T* heap_dis = this->dis_tab + i * k; TI* heap_ids = this->ids_tab + i * k; - const T* dis_tab_i = dis_tab + (j1 - j0) * (i - i0) - j0; + const T* dis_tab_i = + dis_in + (j1 - j0) * (i - static_cast(i0)) - j0; T thresh = heap_dis[0]; for (size_t j = j0; j < j1; j++) { T dis = dis_tab_i[j]; @@ -397,8 +405,8 @@ struct ReservoirTopN : ResultHandlerT { ReservoirTopN() {} - ReservoirTopN(size_t n, size_t capacity, T* vals, TI* ids) - : vals(vals), ids(ids), i(0), n(n), capacity(capacity) { + ReservoirTopN(size_t n_, size_t capacity_, T* vals_, TI* ids_) + : vals(vals_), ids(ids_), i(0), n(n_), capacity(capacity_) { assert(n < capacity); threshold = C::neutral(); } @@ -436,7 +444,7 @@ struct ReservoirTopN : ResultHandlerT { } void to_result(T* heap_dis, TI* heap_ids) const { - for (int j = 0; j < std::min(i, n); j++) { + for (size_t j = 0; j < std::min(i, n); j++) { heap_push(j + 1, heap_dis, heap_ids, vals[j], ids[j]); } @@ -458,16 +466,22 @@ struct ReservoirBlockResultHandler : TopkBlockResultHandler { using TI = typename C::TI; using BlockResultHandler::i0; using BlockResultHandler::i1; + using TopkBlockResultHandler::k; size_t capacity; // capacity of the reservoirs ReservoirBlockResultHandler( - size_t nq, - T* dis_tab, - TI* ids_tab, - size_t k, - const IDSelector* sel = nullptr) - : TopkBlockResultHandler(nq, dis_tab, ids_tab, k, sel) { + size_t nq_, + T* dis_tab_, + TI* ids_tab_, + size_t k_, + const IDSelector* sel_ = nullptr) + : TopkBlockResultHandler( + nq_, + dis_tab_, + ids_tab_, + k_, + sel_) { // double then round up to multiple of 16 (for SIMD alignment) capacity = (2 * k + 15) & ~15; } @@ -483,9 +497,9 @@ struct ReservoirBlockResultHandler : TopkBlockResultHandler { std::vector reservoir_dis; std::vector reservoir_ids; - explicit SingleResultHandler(ReservoirBlockResultHandler& hr) - : ReservoirTopN(hr.k, hr.capacity, nullptr, nullptr), - hr(hr) {} + explicit SingleResultHandler(ReservoirBlockResultHandler& hr_) + : ReservoirTopN(hr_.k, hr_.capacity, nullptr, nullptr), + hr(hr_) {} size_t qno; @@ -533,11 +547,14 @@ struct ReservoirBlockResultHandler : TopkBlockResultHandler { } /// add results for query i0..i1 and j0..j1 - void add_results(size_t j0, size_t j1, const T* dis_tab) { + void add_results(size_t j0, size_t j1, const T* dis_in) { #pragma omp parallel for - for (int64_t i = i0; i < i1; i++) { - ReservoirTopN& reservoir = reservoirs[i - i0]; - const T* dis_tab_i = dis_tab + (j1 - j0) * (i - i0) - j0; + for (int64_t i = static_cast(i0); i < static_cast(i1); + i++) { + ReservoirTopN& reservoir = + reservoirs[i - static_cast(i0)]; + const T* dis_tab_i = + dis_in + (j1 - j0) * (i - static_cast(i0)) - j0; for (size_t j = j0; j < j1; j++) { T dis = dis_tab_i[j]; reservoir.add_result(dis, j); @@ -567,8 +584,8 @@ struct RangeResultHandler : ResultHandlerT { RangeQueryResult* qr = nullptr; - RangeResultHandler(RangeQueryResult* qr, T threshold) : qr(qr) { - this->threshold = threshold; + RangeResultHandler(RangeQueryResult* qr_, T threshold_) : qr(qr_) { + this->threshold = threshold_; } /// add one result for query i @@ -591,12 +608,12 @@ struct RangeSearchBlockResultHandler : BlockResultHandler { T radius; RangeSearchBlockResultHandler( - RangeSearchResult* res, - float radius, - const IDSelector* sel = nullptr) - : BlockResultHandler(res->nq, sel), - res(res), - radius(radius) {} + RangeSearchResult* res_, + float radius_, + const IDSelector* sel_ = nullptr) + : BlockResultHandler(res_->nq, sel_), + res(res_), + radius(radius_) {} /****************************************************** * API for 1 result at a time (each SingleResultHandler is @@ -656,7 +673,7 @@ struct RangeSearchBlockResultHandler : BlockResultHandler { // it is a bit tricky to find the proper PartialResult structure // because the inner loop is on db not on queries. - if (pr < j0s.size() && j0 == j0s[pr]) { + if (static_cast(pr) < j0s.size() && j0 == j0s[pr]) { pres = partial_results[pr]; pr++; } else if (j0 == 0 && j0s.size() > 0) { @@ -718,7 +735,7 @@ typename Consumer::T dispatch_knn_ResultHandler( if (k == 1) { \ Top1BlockResultHandler res(nx, vals, ids, sel); \ return consumer.template f<>(res, args...); \ - } else if (k < distance_compute_min_k_reservoir) { \ + } else if (k < static_cast(distance_compute_min_k_reservoir)) { \ HeapBlockResultHandler res(nx, vals, ids, k, sel); \ return consumer.template f<>(res, args...); \ } else { \ diff --git a/faiss/impl/index_read.cpp b/faiss/impl/index_read.cpp index 9cd62dfd8..fc312404b 100644 --- a/faiss/impl/index_read.cpp +++ b/faiss/impl/index_read.cpp @@ -303,8 +303,9 @@ std::unique_ptr read_VectorTransform_up(IOReader* f) { READ1(lt->have_bias); READVECTOR(lt->A); READVECTOR(lt->b); - FAISS_THROW_IF_NOT(lt->A.size() >= lt->d_in * lt->d_out); - FAISS_THROW_IF_NOT(!lt->have_bias || lt->b.size() >= lt->d_out); + FAISS_THROW_IF_NOT( + lt->A.size() >= size_t(lt->d_in) * size_t(lt->d_out)); + FAISS_THROW_IF_NOT(!lt->have_bias || lt->b.size() >= size_t(lt->d_out)); lt->set_is_orthonormal(); vt = std::move(lt); } else if (h == fourcc("RmDT")) { @@ -1329,7 +1330,7 @@ std::unique_ptr read_index_up(IOReader* f, int io_flags) { "invalid IVFFlatDedup instances table size: %zd " "(must be even)", tab.size()); - for (long i = 0; i < tab.size(); i += 2) { + for (size_t i = 0; i < tab.size(); i += 2) { std::pair pair(tab[i], tab[i + 1]); ivfl->instances.insert(pair); } @@ -1389,7 +1390,7 @@ std::unique_ptr read_index_up(IOReader* f, int io_flags) { read_ScalarQuantizer(&ivsc->sq, f); READ1(ivsc->code_size); ArrayInvertedLists* ail = set_array_invlist(ivsc.get(), ids); - for (int i = 0; i < ivsc->nlist; i++) + for (size_t i = 0; i < ivsc->nlist; i++) READVECTOR(ail->codes[i]); idx = std::move(ivsc); } else if (h == fourcc("IwSQ") || h == fourcc("IwSq")) { diff --git a/faiss/impl/index_write.cpp b/faiss/impl/index_write.cpp index 04257c76a..03cc9bdd6 100644 --- a/faiss/impl/index_write.cpp +++ b/faiss/impl/index_write.cpp @@ -648,13 +648,13 @@ void write_index(const Index* idx, IOWriter* f, int io_flags) { write_InvertedLists(ivaqfs->invlists, f); } else if ( - const ResidualCoarseQuantizer* idxr_2 = + const ResidualCoarseQuantizer* idxrcq = dynamic_cast(idx)) { uint32_t h = fourcc("ImRQ"); WRITE1(h); write_index_header(idx, f); - write_ResidualQuantizer(&idxr_2->rq, f); - WRITE1(idxr_2->beam_factor); + write_ResidualQuantizer(&idxrcq->rq, f); + WRITE1(idxrcq->beam_factor); } else if ( const Index2Layer* idxp_2 = dynamic_cast(idx)) { uint32_t h = fourcc("Ix2L"); @@ -1165,7 +1165,7 @@ static void write_binary_multi_hash_map( size_t ntotal, IOWriter* f) { int id_bits = 0; - while ((ntotal > ((idx_t)1 << id_bits))) { + while ((ntotal > (size_t(1) << id_bits))) { id_bits++; } WRITE1(id_bits); diff --git a/faiss/impl/io.cpp b/faiss/impl/io.cpp index 13ce51e07..cf0018351 100644 --- a/faiss/impl/io.cpp +++ b/faiss/impl/io.cpp @@ -134,14 +134,14 @@ int FileIOWriter::filedescriptor() { * IO buffer ***********************************************************************/ -BufferedIOReader::BufferedIOReader(IOReader* reader, size_t bsz) - : reader(reader), - bsz(bsz), +BufferedIOReader::BufferedIOReader(IOReader* reader_in, size_t bsz_in) + : reader(reader_in), + bsz(bsz_in), ofs(0), ofs2(0), b0(0), b1(0), - buffer(bsz) {} + buffer(bsz_in) {} size_t BufferedIOReader::operator()(void* ptr, size_t unitsize, size_t nitems) { size_t size = unitsize * nitems; @@ -184,8 +184,8 @@ size_t BufferedIOReader::operator()(void* ptr, size_t unitsize, size_t nitems) { return nb / unitsize; } -BufferedIOWriter::BufferedIOWriter(IOWriter* writer, size_t bsz) - : writer(writer), bsz(bsz), ofs2(0), b0(0), buffer(bsz) {} +BufferedIOWriter::BufferedIOWriter(IOWriter* writer_in, size_t bsz_in) + : writer(writer_in), bsz(bsz_in), ofs2(0), b0(0), buffer(bsz_in) {} size_t BufferedIOWriter::operator()( const void* ptr, diff --git a/faiss/impl/kmeans1d.cpp b/faiss/impl/kmeans1d.cpp index db3a54a41..c1cc7772a 100644 --- a/faiss/impl/kmeans1d.cpp +++ b/faiss/impl/kmeans1d.cpp @@ -48,12 +48,12 @@ void interpolate( const LookUpFunc& lookup, idx_t* argmins) { std::unordered_map idx_to_col; - for (idx_t idx = 0; idx < cols.size(); ++idx) { + for (size_t idx = 0; idx < cols.size(); ++idx) { idx_to_col[cols[idx]] = idx; } idx_t start = 0; - for (idx_t r = 0; r < rows.size(); r += 2) { + for (size_t r = 0; r < rows.size(); r += 2) { idx_t row = rows[r]; idx_t end = cols.size() - 1; if (r < rows.size() - 1) { @@ -107,7 +107,7 @@ void smawk_impl( // call recursively on odd-indexed rows std::vector odd_rows; - for (idx_t i = 1; i < rows.size(); i += 2) { + for (size_t i = 1; i < rows.size(); i += 2) { odd_rows.push_back(rows[i]); } smawk_impl(odd_rows, cols, lookup, argmins); @@ -175,10 +175,10 @@ class Matrix { idx_t ncols; public: - Matrix(idx_t nrows, idx_t ncols) { - this->nrows = nrows; - this->ncols = ncols; - data.resize(nrows * ncols); + Matrix(idx_t nrows_in, idx_t ncols_in) { + this->nrows = nrows_in; + this->ncols = ncols_in; + data.resize(nrows_in * ncols_in); } inline T& at(idx_t i, idx_t j) { @@ -240,14 +240,14 @@ double kmeans1d(const float* x, size_t n, size_t nclusters, float* centroids) { Matrix D(nclusters, n); Matrix T(nclusters, n); - for (idx_t m = 0; m < n; m++) { + for (idx_t m = 0; m < static_cast(n); m++) { D.at(0, m) = CC(0, m); T.at(0, m) = 0; } std::vector indices(nclusters, 0); - for (idx_t k = 1; k < nclusters; ++k) { + for (idx_t k = 1; k < static_cast(nclusters); ++k) { // we define C here auto C = [&D, &CC, &k](idx_t m, idx_t i) { if (i == 0) { @@ -259,7 +259,7 @@ double kmeans1d(const float* x, size_t n, size_t nclusters, float* centroids) { std::vector argmins(n); // argmin of each row smawk(n, n, C, argmins.data()); - for (idx_t m = 0; m < argmins.size(); m++) { + for (size_t m = 0; m < argmins.size(); m++) { idx_t idx = argmins[m]; D.at(k, m) = C(m, idx); T.at(k, m) = idx; diff --git a/faiss/impl/lattice_Zn.cpp b/faiss/impl/lattice_Zn.cpp index 3b87d73ab..76b1084c6 100644 --- a/faiss/impl/lattice_Zn.cpp +++ b/faiss/impl/lattice_Zn.cpp @@ -41,7 +41,7 @@ struct Comb { std::vector tab; // Pascal's triangle int nmax; - explicit Comb(int nmax) : nmax(nmax) { + explicit Comb(int nmax_in) : nmax(nmax_in) { tab.resize(nmax * nmax, 0); tab[0] = 1; for (int i = 1; i < nmax; i++) { @@ -172,9 +172,9 @@ void repeats_decode_64( } // anonymous namespace -Repeats::Repeats(int dim, const float* c) : dim(dim) { +Repeats::Repeats(int dim_in, const float* c) : dim(dim_in) { for (int i = 0; i < dim; i++) { - int j = 0; + size_t j = 0; for (;;) { if (j == repeats.size()) { repeats.push_back(Repeat{c[i], 1}); @@ -192,7 +192,7 @@ Repeats::Repeats(int dim, const float* c) : dim(dim) { uint64_t Repeats::count() const { uint64_t accu = 1; int remain = dim; - for (int i = 0; i < repeats.size(); i++) { + for (size_t i = 0; i < repeats.size(); i++) { accu *= comb(remain, repeats[i].n); remain -= repeats[i].n; } @@ -275,7 +275,7 @@ void EnumeratedVectors::encode_multi(size_t n, const float* c, uint64_t* codes) #pragma omp parallel if (n > 1000) { #pragma omp for - for (int i = 0; i < n; i++) { + for (int64_t i = 0; i < static_cast(n); i++) { codes[i] = encode(c + i * dim); } } @@ -286,7 +286,7 @@ void EnumeratedVectors::decode_multi(size_t n, const uint64_t* codes, float* c) #pragma omp parallel if (n > 1000) { #pragma omp for - for (int i = 0; i < n; i++) { + for (int64_t i = 0; i < static_cast(n); i++) { decode(codes[i], c + i * dim); } } @@ -325,11 +325,11 @@ void EnumeratedVectors::find_nn( * ZnSphereSearch **********************************************************/ -ZnSphereSearch::ZnSphereSearch(int dim, int r2) : dimS(dim), r2(r2) { +ZnSphereSearch::ZnSphereSearch(int dim, int r2_in) : dimS(dim), r2(r2_in) { FAISS_THROW_IF_NOT_MSG( dim > 0 && dim <= 64, "ZnSphereSearch: dim must be in [1, 64]"); FAISS_THROW_IF_NOT_MSG( - r2 >= 0 && r2 <= 512, + r2_in >= 0 && r2_in <= 512, "ZnSphereSearch: r2 must be in [0, 512] to avoid" " excessive computation in sum_of_sq"); voc = sum_of_sq(r2, int(ceil(sqrt(r2)) + 1), dim); @@ -404,8 +404,8 @@ void ZnSphereSearch::search_multi( * ZnSphereCodec **********************************************************/ -ZnSphereCodec::ZnSphereCodec(int dim, int r2) - : ZnSphereSearch(dim, r2), EnumeratedVectors(dim) { +ZnSphereCodec::ZnSphereCodec(int dim_in, int r2_in) + : ZnSphereSearch(dim_in, r2_in), EnumeratedVectors(dim_in) { nv = 0; for (int i = 0; i < natom; i++) { Repeats repeats(dim, &voc[i * dim]); @@ -497,10 +497,10 @@ void ZnSphereCodecRec::set_nv_cum(int ld, int r2t, int r2a, uint64_t cum) { all_nv_cum[(ld * (r2 + 1) + r2t) * (r2 + 1) + r2a] = cum; } -ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2) - : EnumeratedVectors(dim), r2(r2) { +ZnSphereCodecRec::ZnSphereCodecRec(int dim_in, int r2_in) + : EnumeratedVectors(dim_in), r2(r2_in) { FAISS_THROW_IF_NOT_MSG( - dim > 0 && r2 >= 0, "invalid ZnSphereCodecRec parameters"); + dim_in > 0 && r2_in >= 0, "invalid ZnSphereCodecRec parameters"); log2_dim = 0; while (dim > (1 << log2_dim)) { log2_dim++; @@ -533,13 +533,13 @@ ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2) for (int ld = 1; ld <= log2_dim; ld++) { for (int r2sub = 0; r2sub <= r2; r2sub++) { - uint64_t nv = 0; + uint64_t nv_acc = 0; for (int r2a = 0; r2a <= r2sub; r2a++) { int r2b = r2sub - r2a; - set_nv_cum(ld, r2sub, r2a, nv); - nv += get_nv(ld - 1, r2a) * get_nv(ld - 1, r2b); + set_nv_cum(ld, r2sub, r2a, nv_acc); + nv_acc += get_nv(ld - 1, r2a) * get_nv(ld - 1, r2b); } - all_nv[ld * (r2 + 1) + r2sub] = nv; + all_nv[ld * (r2 + 1) + r2sub] = nv_acc; } } nv = get_nv(log2_dim, r2); @@ -564,7 +564,7 @@ ZnSphereCodecRec::ZnSphereCodecRec(int dim, int r2) cache.resize(nvi * dimsub); std::vector c(dim); uint64_t code0 = get_nv_cum(cache_level + 1, r2, r2 - r2sub); - for (int i = 0; i < nvi; i++) { + for (uint64_t i = 0; i < nvi; i++) { decode(i + code0, c.data()); memcpy(&cache[i * dimsub], c.data() + dim - dimsub, @@ -670,10 +670,10 @@ void ZnSphereCodecRec::decode(uint64_t code, float* c) const { } // if not use_rec, instantiate an arbitrary harmless znc_rec -ZnSphereCodecAlt::ZnSphereCodecAlt(int dim, int r2) - : ZnSphereCodec(dim, r2), - use_rec((dim & (dim - 1)) == 0), - znc_rec(use_rec ? dim : 8, use_rec ? r2 : 14) {} +ZnSphereCodecAlt::ZnSphereCodecAlt(int dim_in, int r2_in) + : ZnSphereCodec(dim_in, r2_in), + use_rec((dim_in & (dim_in - 1)) == 0), + znc_rec(use_rec ? dim_in : 8, use_rec ? r2_in : 14) {} uint64_t ZnSphereCodecAlt::encode(const float* x) const { if (!use_rec) { diff --git a/faiss/impl/lattice_Zn.h b/faiss/impl/lattice_Zn.h index 77d6d2816..bd10cdc16 100644 --- a/faiss/impl/lattice_Zn.h +++ b/faiss/impl/lattice_Zn.h @@ -29,7 +29,7 @@ struct ZnSphereSearch { /// size dim * natom std::vector voc; - ZnSphereSearch(int dim, int r2); + ZnSphereSearch(int dim, int r2_in); /// find nearest centroid. x does not need to be normalized float search(const float* x, float* c) const; @@ -57,7 +57,7 @@ struct EnumeratedVectors { uint64_t nv; int dim; - explicit EnumeratedVectors(int dim) : nv(0), dim(dim) {} + explicit EnumeratedVectors(int dim_in) : nv(0), dim(dim_in) {} /// encode a vector from a collection virtual uint64_t encode(const float* x) const = 0; @@ -98,7 +98,7 @@ struct Repeats { std::vector repeats; // initialize from a template of the atom. - Repeats(int dim = 0, const float* c = nullptr); + Repeats(int dim_in = 0, const float* c = nullptr); // count number of possible codes for this atom uint64_t count() const; @@ -124,7 +124,7 @@ struct ZnSphereCodec : ZnSphereSearch, EnumeratedVectors { uint64_t nv; size_t code_size; - ZnSphereCodec(int dim, int r2); + ZnSphereCodec(int dim_in, int r2_in); uint64_t search_and_encode(const float* x) const; @@ -146,7 +146,7 @@ struct ZnSphereCodecRec : EnumeratedVectors { int log2_dim; int code_size; - ZnSphereCodecRec(int dim, int r2); + ZnSphereCodecRec(int dim_in, int r2_in); uint64_t encode_centroid(const float* c) const; @@ -176,7 +176,7 @@ struct ZnSphereCodecAlt : ZnSphereCodec { bool use_rec; ZnSphereCodecRec znc_rec; - ZnSphereCodecAlt(int dim, int r2); + ZnSphereCodecAlt(int dim_in, int r2_in); uint64_t encode(const float* x) const override;