facebookresearch/faiss
1
0
Fork 0
mirror of https://github.com/facebookresearch/faiss.git synced 2026-10-12 02:13:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: resolve compiler warnings in IO, result handlers, and misc impl (#4936)

Browse Source 
Summary:
- Fix compiler warnings in index_read, index_write, IO utilities, ResultHandler, simd_result_handlers, fast_scan
- Also covers IDSelector, AuxIndexStructures, CodePacker, PolysemousTraining, kmeans1d, lattice_Zn
- Fixes include `-Wshadow`, `-Wunused-parameter`, `-Wformat`, and `-Wimplicit-fallthrough`

All changes are mechanical. No functional changes.

Part 5/13 of the compiler warnings cleanup (split from https://github.com/facebookresearch/faiss/issues/4810 per maintainer request).

Pull Request resolved: https://github.com/facebookresearch/faiss/pull/4936

Test Plan:
- [x] No functional changes — all fixes are mechanical renames and annotations

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Reviewed By: limqiying

Differential Revision: D96995986

Pulled By: alibeklfc

fbshipit-source-id: abfac3dceaa9a64752f3ac908c9a53c0f44bb2fa
This commit is contained in:
Max Buckley
2026-03-20 10:18:23 -07:00
committed by meta-codesync[bot]
co-authored by Claude Opus 4.6
parent a05f13ff6a
commit 64a2122ef1
13 changed files with 214 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files
faiss/impl/AuxIndexStructures.cpp
+10 -9
View File
@@ -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(
faiss/impl/CodePacker.cpp
+3 -3
View File
@@ -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 {
faiss/impl/IDSelector.cpp
+13 -9
View File
@@ -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;
faiss/impl/IDSelector.h
+8 -8
View File
@@ -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);
}
faiss/impl/PolysemousTraining.cpp
+37 -31
View File
@@ -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<double>& 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<float, double> {
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<int>(pq.M); m++) {
std::vector<double> 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<int>(pq.M); m++) {
size_t nq, nb;
std::vector<uint32_t> codes; // query codes, then db codes
std::vector<float> gt_distances; // nq * nb matrix of distances
if (n > 0) {
std::vector<float> 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<uint32_t>(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<float> 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]));
faiss/impl/PolysemousTraining.h
+3 -3
View File
@@ -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;
faiss/impl/ResultHandler.h
+87 -70
View File
@@ -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<C, use_sel> {
ResultHandler& the_handler;
explicit SingleQueryBlockResultHandler(
ResultHandler& the_handler,
const IDSelector* sel = nullptr)
: BlockResultHandler<C, use_sel>(1, sel),
the_handler(the_handler) {}
ResultHandler& the_handler_in,
const IDSelector* sel_in = nullptr)
: BlockResultHandler<C, use_sel>(1, sel_in),
the_handler(the_handler_in) {}
struct SingleResultHandler : ResultHandlerT<C> {
ResultHandler& the_handler;
@@ -121,9 +121,7 @@ struct SingleQueryBlockResultHandler : BlockResultHandler<C, use_sel> {
: 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<C, use_sel> {
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<C, use_sel>(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<C, use_sel>(nq_, sel_),
dis_tab(dis_tab_),
ids_tab(ids_tab_),
k(k_) {}
~TopkBlockResultHandler() {}
};
@@ -176,12 +174,16 @@ struct Top1BlockResultHandler : TopkBlockResultHandler<C, use_sel> {
using BlockResultHandler<C, use_sel>::i1;
Top1BlockResultHandler(
size_t nq,
T* dis_tab,
TI* ids_tab,
const IDSelector* sel = nullptr)
: TopkBlockResultHandler<C, use_sel>(nq, dis_tab, ids_tab, 1, sel) {
}
size_t nq_,
T* dis_tab_,
TI* ids_tab_,
const IDSelector* sel_ = nullptr)
: TopkBlockResultHandler<C, use_sel>(
nq_,
dis_tab_,
ids_tab_,
1,
sel_) {}
struct SingleResultHandler : ResultHandlerT<C> {
Top1BlockResultHandler& hr;
@@ -190,7 +192,7 @@ struct Top1BlockResultHandler : TopkBlockResultHandler<C, use_sel> {
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<C, use_sel> {
};
/// 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<C, use_sel> {
/// 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<C> {
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<C, use_sel> {
using TopkBlockResultHandler<C, use_sel>::k;
HeapBlockResultHandler(
size_t nq,
T* dis_tab,
TI* ids_tab,
size_t k,
const IDSelector* sel = nullptr)
: TopkBlockResultHandler<C, use_sel>(nq, dis_tab, ids_tab, k, sel) {
}
size_t nq_,
T* dis_tab_,
TI* ids_tab_,
size_t k_,
const IDSelector* sel_ = nullptr)
: TopkBlockResultHandler<C, use_sel>(
nq_,
dis_tab_,
ids_tab_,
k_,
sel_) {}
/******************************************************
* API for 1 result at a time (each SingleResultHandler is
@@ -313,9 +319,9 @@ struct HeapBlockResultHandler : TopkBlockResultHandler<C, use_sel> {
struct SingleResultHandler : HeapResultHandler<C, use_sel> {
HeapBlockResultHandler& hr;
explicit SingleResultHandler(HeapBlockResultHandler& hr)
: HeapResultHandler<C, use_sel>(hr.k, nullptr, nullptr),
hr(hr) {}
explicit SingleResultHandler(HeapBlockResultHandler& hr_)
: HeapResultHandler<C, use_sel>(hr_.k, nullptr, nullptr),
hr(hr_) {}
/// begin results for query # i
void begin(size_t i) {
@@ -346,12 +352,14 @@ struct HeapBlockResultHandler : TopkBlockResultHandler<C, use_sel> {
}
/// 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<int64_t>(i0); i < static_cast<int64_t>(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<int64_t>(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<C> {
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<C> {
}
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<C>(j + 1, heap_dis, heap_ids, vals[j], ids[j]);
}
@@ -458,16 +466,22 @@ struct ReservoirBlockResultHandler : TopkBlockResultHandler<C, use_sel> {
using TI = typename C::TI;
using BlockResultHandler<C, use_sel>::i0;
using BlockResultHandler<C, use_sel>::i1;
using TopkBlockResultHandler<C, use_sel>::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<C, use_sel>(nq, dis_tab, ids_tab, k, sel) {
size_t nq_,
T* dis_tab_,
TI* ids_tab_,
size_t k_,
const IDSelector* sel_ = nullptr)
: TopkBlockResultHandler<C, use_sel>(
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<C, use_sel> {
std::vector<T> reservoir_dis;
std::vector<TI> reservoir_ids;
explicit SingleResultHandler(ReservoirBlockResultHandler& hr)
: ReservoirTopN<C>(hr.k, hr.capacity, nullptr, nullptr),
hr(hr) {}
explicit SingleResultHandler(ReservoirBlockResultHandler& hr_)
: ReservoirTopN<C>(hr_.k, hr_.capacity, nullptr, nullptr),
hr(hr_) {}
size_t qno;
@@ -533,11 +547,14 @@ struct ReservoirBlockResultHandler : TopkBlockResultHandler<C, use_sel> {
}
/// 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<C>& reservoir = reservoirs[i - i0];
const T* dis_tab_i = dis_tab + (j1 - j0) * (i - i0) - j0;
for (int64_t i = static_cast<int64_t>(i0); i < static_cast<int64_t>(i1);
i++) {
ReservoirTopN<C>& reservoir =
reservoirs[i - static_cast<int64_t>(i0)];
const T* dis_tab_i =
dis_in + (j1 - j0) * (i - static_cast<int64_t>(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<C> {
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<C, use_sel> {
T radius;
RangeSearchBlockResultHandler(
RangeSearchResult* res,
float radius,
const IDSelector* sel = nullptr)
: BlockResultHandler<C, use_sel>(res->nq, sel),
res(res),
radius(radius) {}
RangeSearchResult* res_,
float radius_,
const IDSelector* sel_ = nullptr)
: BlockResultHandler<C, use_sel>(res_->nq, sel_),
res(res_),
radius(radius_) {}
/******************************************************
* API for 1 result at a time (each SingleResultHandler is
@@ -656,7 +673,7 @@ struct RangeSearchBlockResultHandler : BlockResultHandler<C, use_sel> {
// 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<size_t>(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<C, use_sel> res(nx, vals, ids, sel); \
return consumer.template f<>(res, args...); \
} else if (k < distance_compute_min_k_reservoir) { \
} else if (k < static_cast<size_t>(distance_compute_min_k_reservoir)) { \
HeapBlockResultHandler<C, use_sel> res(nx, vals, ids, k, sel); \
return consumer.template f<>(res, args...); \
} else { \
faiss/impl/index_read.cpp
+5 -4
View File
@@ -303,8 +303,9 @@ std::unique_ptr<VectorTransform> 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<Index> 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<idx_t, idx_t> pair(tab[i], tab[i + 1]);
ivfl->instances.insert(pair);
}
@@ -1389,7 +1390,7 @@ std::unique_ptr<Index> 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")) {
faiss/impl/index_write.cpp
+4 -4
View File
@@ -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<const ResidualCoarseQuantizer*>(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<const Index2Layer*>(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);
faiss/impl/io.cpp
+6 -6
View File
@@ -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,
faiss/impl/kmeans1d.cpp
+10 -10
View File
@@ -48,12 +48,12 @@ void interpolate(
const LookUpFunc& lookup,
idx_t* argmins) {
std::unordered_map<idx_t, idx_t> 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<idx_t> 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<float> D(nclusters, n);
Matrix<idx_t> T(nclusters, n);
for (idx_t m = 0; m < n; m++) {
for (idx_t m = 0; m < static_cast<idx_t>(n); m++) {
D.at(0, m) = CC(0, m);
T.at(0, m) = 0;
}
std::vector<idx_t> indices(nclusters, 0);
for (idx_t k = 1; k < nclusters; ++k) {
for (idx_t k = 1; k < static_cast<idx_t>(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<idx_t> 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;
faiss/impl/lattice_Zn.cpp
+22 -22
View File
@@ -41,7 +41,7 @@ struct Comb {
std::vector<uint64_t> 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<int64_t>(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<int64_t>(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<float> 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) {
faiss/impl/lattice_Zn.h
+6 -6
View File
@@ -29,7 +29,7 @@ struct ZnSphereSearch {
/// size dim * natom
std::vector<float> 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<Repeat> 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;