Skip to content

fix: resolve compiler warnings in binary and miscellaneous Index files #4940

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
maxwbuckley wants to merge 3 commits into from
Closed

fix: resolve compiler warnings in binary and miscellaneous Index files #4940

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
b4f71aa
fix: resolve compiler warnings (index-binary-misc)
maxwbuckley Mar 18, 2026
ad060eb
style: fix clang-format-21 formatting
maxwbuckley Mar 20, 2026
90f993c
fix: use renamed local variable qbs_ in search_implem_12
maxwbuckley Mar 20, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 7 additions & 6 deletions faiss/Index2Layer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -142,8 +142,8 @@ struct Distance2Level : DistanceComputer {

const float *pq_l1_tab, *pq_l2_tab;

explicit Distance2Level(const Index2Layer& storage) : storage(storage) {
d = storage.d;
explicit Distance2Level(const Index2Layer& storage_) : storage(storage_) {
d = storage_.d;
FAISS_ASSERT(storage.pq.dsub == 4);
pq_l2_tab = storage.pq.centroids.data();
buf.resize(2 * d);
Expand All @@ -164,8 +164,8 @@ struct Distance2Level : DistanceComputer {
struct DistanceXPQ4 : Distance2Level {
int M, k;

explicit DistanceXPQ4(const Index2Layer& storage)
: Distance2Level(storage) {
explicit DistanceXPQ4(const Index2Layer& storage_)
: Distance2Level(storage_) {
const IndexFlat* quantizer =
dynamic_cast<IndexFlat*>(storage.q1.quantizer);

Expand Down Expand Up @@ -200,6 +200,7 @@ struct DistanceXPQ4 : Distance2Level {
accu = _mm_hadd_ps(accu, accu);
return _mm_cvtss_f32(accu);
#else
(void)i;
FAISS_THROW_MSG("not implemented for non-x64 platforms");
#endif
}
Expand All @@ -209,8 +210,8 @@ struct DistanceXPQ4 : Distance2Level {
struct Distance2xXPQ4 : Distance2Level {
int M_2, mi_nbits;

explicit Distance2xXPQ4(const Index2Layer& storage)
: Distance2Level(storage) {
explicit Distance2xXPQ4(const Index2Layer& storage_)
: Distance2Level(storage_) {
const MultiIndexQuantizer* mi =
dynamic_cast<MultiIndexQuantizer*>(storage.q1.quantizer);

Expand Down
66 changes: 34 additions & 32 deletions faiss/IndexAdditiveQuantizer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,10 +22,10 @@ namespace faiss {
**************************************************************************************/

IndexAdditiveQuantizer::IndexAdditiveQuantizer(
idx_t d,
AdditiveQuantizer* aq,
idx_t d_,
AdditiveQuantizer* aq_,
MetricType metric)
: IndexFlatCodes(aq->code_size, d, metric), aq(aq) {
: IndexFlatCodes(aq_->code_size, d_, metric), aq(aq_) {
FAISS_THROW_IF_NOT(metric == METRIC_INNER_PRODUCT || metric == METRIC_L2);
}

Expand All @@ -44,11 +44,11 @@ struct AQDistanceComputerDecompress : FlatCodesDistanceComputer {

AQDistanceComputerDecompress(
const IndexAdditiveQuantizer& iaq,
VectorDistance vd)
VectorDistance vd_)
: FlatCodesDistanceComputer(iaq.codes.data(), iaq.code_size),
tmp(iaq.d * 2),
aq(*iaq.aq),
vd(vd),
vd(vd_),
d(iaq.d) {}

const float* q;
Expand Down Expand Up @@ -127,7 +127,7 @@ void search_with_decompress(
typename BlockResultHandler::SingleResultHandler;

#pragma omp parallel for if (res.nq > 100)
for (int64_t q = 0; q < res.nq; q++) {
for (int64_t q = 0; q < static_cast<int64_t>(res.nq); q++) {
SingleResultHandler resi(res);
resi.begin(q);
std::vector<float> tmp(ir.d);
Expand Down Expand Up @@ -163,7 +163,7 @@ void search_with_LUT(
aq.compute_LUT(nq, xq, LUT.get());

#pragma omp parallel for if (nq > 100)
for (int64_t q = 0; q < nq; q++) {
for (int64_t q = 0; q < static_cast<int64_t>(nq); q++) {
SingleResultHandler resi(res);
resi.begin(q);
std::vector<float> tmp(aq.d);
Expand Down Expand Up @@ -298,23 +298,23 @@ void IndexAdditiveQuantizer::sa_decode(idx_t n, const uint8_t* bytes, float* x)
**************************************************************************************/

IndexResidualQuantizer::IndexResidualQuantizer(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type)
: IndexResidualQuantizer(
d,
d_,
std::vector<size_t>(M, nbits),
metric,
search_type) {}

IndexResidualQuantizer::IndexResidualQuantizer(
int d,
int d_,
const std::vector<size_t>& nbits,
MetricType metric,
Search_type_t search_type)
: IndexAdditiveQuantizer(d, &rq, metric), rq(d, nbits, search_type) {
: IndexAdditiveQuantizer(d_, &rq, metric), rq(d_, nbits, search_type) {
code_size = rq.code_size;
is_trained = false;
}
Expand All @@ -332,13 +332,13 @@ void IndexResidualQuantizer::train(idx_t n, const float* x) {
**************************************************************************************/

IndexLocalSearchQuantizer::IndexLocalSearchQuantizer(
int d,
int d_,
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type)
: IndexAdditiveQuantizer(d, &lsq, metric),
lsq(d, M, nbits, search_type) {
: IndexAdditiveQuantizer(d_, &lsq, metric),
lsq(d_, M, nbits, search_type) {
code_size = lsq.code_size;
is_trained = false;
}
Expand All @@ -356,14 +356,14 @@ void IndexLocalSearchQuantizer::train(idx_t n, const float* x) {
**************************************************************************************/

IndexProductResidualQuantizer::IndexProductResidualQuantizer(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t nsplits, ///< number of residual quantizers
size_t Msub, ///< number of subquantizers per RQ
size_t nbits, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type)
: IndexAdditiveQuantizer(d, &prq, metric),
prq(d, nsplits, Msub, nbits, search_type) {
: IndexAdditiveQuantizer(d_, &prq, metric),
prq(d_, nsplits, Msub, nbits, search_type) {
code_size = prq.code_size;
is_trained = false;
}
Expand All @@ -381,14 +381,14 @@ void IndexProductResidualQuantizer::train(idx_t n, const float* x) {
**************************************************************************************/

IndexProductLocalSearchQuantizer::IndexProductLocalSearchQuantizer(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t nsplits, ///< number of local search quantizers
size_t Msub, ///< number of subquantizers per LSQ
size_t nbits, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type)
: IndexAdditiveQuantizer(d, &plsq, metric),
plsq(d, nsplits, Msub, nbits, search_type) {
: IndexAdditiveQuantizer(d_, &plsq, metric),
plsq(d_, nsplits, Msub, nbits, search_type) {
code_size = plsq.code_size;
is_trained = false;
}
Expand All @@ -406,10 +406,10 @@ void IndexProductLocalSearchQuantizer::train(idx_t n, const float* x) {
**************************************************************************************/

AdditiveCoarseQuantizer::AdditiveCoarseQuantizer(
idx_t d,
AdditiveQuantizer* aq,
idx_t d_,
AdditiveQuantizer* aq_,
MetricType metric)
: Index(d, metric), aq(aq) {}
: Index(d_, metric), aq(aq_) {}

void AdditiveCoarseQuantizer::add(idx_t, const float*) {
FAISS_THROW_MSG("not applicable");
Expand Down Expand Up @@ -463,7 +463,8 @@ void AdditiveCoarseQuantizer::search(
if (metric_type == METRIC_INNER_PRODUCT) {
aq->knn_centroids_inner_product(n, x, k, distances, labels);
} else if (metric_type == METRIC_L2) {
FAISS_THROW_IF_NOT(centroid_norms.size() == ntotal);
FAISS_THROW_IF_NOT(
centroid_norms.size() == static_cast<size_t>(ntotal));
aq->knn_centroids_L2(n, x, k, distances, labels, centroid_norms.data());
}
}
Expand All @@ -473,20 +474,20 @@ void AdditiveCoarseQuantizer::search(
**************************************************************************************/

ResidualCoarseQuantizer::ResidualCoarseQuantizer(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
const std::vector<size_t>& nbits,
MetricType metric)
: AdditiveCoarseQuantizer(d, &rq, metric), rq(d, nbits) {
: AdditiveCoarseQuantizer(d_, &rq, metric), rq(d_, nbits) {
FAISS_THROW_IF_NOT(rq.tot_bits <= 63);
is_trained = false;
}

ResidualCoarseQuantizer::ResidualCoarseQuantizer(
int d,
int d_,
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
MetricType metric)
: ResidualCoarseQuantizer(d, std::vector<size_t>(M, nbits), metric) {}
: ResidualCoarseQuantizer(d_, std::vector<size_t>(M, nbits), metric) {}

ResidualCoarseQuantizer::ResidualCoarseQuantizer()
: ResidualCoarseQuantizer(0, 0, 0) {}
Expand All @@ -504,7 +505,8 @@ void ResidualCoarseQuantizer::set_beam_factor(float new_beam_factor) {
// Does not use the cross_products
rq.codebook_cross_products.resize(0);
// but the centroid norms are necessary!
if (metric_type == METRIC_L2 && ntotal != centroid_norms.size()) {
if (metric_type == METRIC_L2 &&
static_cast<size_t>(ntotal) != centroid_norms.size()) {
if (verbose) {
printf("AdditiveCoarseQuantizer::train: computing centroid norms for %zd centroids\n",
size_t(ntotal));
Expand Down Expand Up @@ -590,7 +592,7 @@ void ResidualCoarseQuantizer::search(
for (idx_t j = 0; j < k; j++) {
idx_t l = 0;
int shift = 0;
for (int m = 0; m < rq.M; m++) {
for (size_t m = 0; m < rq.M; m++) {
l |= (*codes_i++) << shift;
shift += rq.nbits[m];
}
Expand All @@ -613,11 +615,11 @@ void ResidualCoarseQuantizer::initialize_from(
**************************************************************************************/

LocalSearchCoarseQuantizer::LocalSearchCoarseQuantizer(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
MetricType metric)
: AdditiveCoarseQuantizer(d, &lsq, metric), lsq(d, M, nbits) {
: AdditiveCoarseQuantizer(d_, &lsq, metric), lsq(d_, M, nbits) {
FAISS_THROW_IF_NOT(lsq.tot_bits <= 63);
is_trained = false;
}
Expand Down
58 changes: 29 additions & 29 deletions faiss/IndexAdditiveQuantizerFastScan.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,16 +25,16 @@ inline size_t roundup(size_t a, size_t b) {
}

IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
AdditiveQuantizer* aq,
AdditiveQuantizer* aq_,
MetricType metric,
int bbs) {
init(aq, metric, bbs);
int bbs_) {
init(aq_, metric, bbs_);
}

void IndexAdditiveQuantizerFastScan::init(
AdditiveQuantizer* aq_init,
MetricType metric,
int bbs) {
int bbs_) {
FAISS_THROW_IF_NOT(aq_init != nullptr);
FAISS_THROW_IF_NOT(!aq_init->nbits.empty());
FAISS_THROW_IF_NOT(aq_init->nbits[0] == 4);
Expand All @@ -56,7 +56,7 @@ void IndexAdditiveQuantizerFastScan::init(
} else {
M = aq_init->M;
}
init_fastscan(aq_init->d, M, 4, metric, bbs);
init_fastscan(aq_init->d, M, 4, metric, bbs_);

max_train_points = 1024 * ksub * M;
}
Expand All @@ -69,8 +69,8 @@ IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan()

IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
const IndexAdditiveQuantizer& orig,
int bbs) {
init(orig.aq, orig.metric_type, bbs);
int bbs_) {
init(orig.aq, orig.metric_type, bbs_);

ntotal = orig.ntotal;
is_trained = orig.is_trained;
Expand Down Expand Up @@ -222,14 +222,14 @@ void IndexAdditiveQuantizerFastScan::sa_decode(
**************************************************************************************/

IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan(
int d, ///< dimensionality of the input vectors
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
int d_, ///< dimensionality of the input vectors
size_t M_, ///< number of subquantizers
size_t nbits_, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type,
int bbs)
: rq(d, M, nbits, search_type) {
init(&rq, metric, bbs);
int bbs_)
: rq(d_, M_, nbits_, search_type) {
init(&rq, metric, bbs_);
}

IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
Expand All @@ -241,14 +241,14 @@ IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
**************************************************************************************/

IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan(
int d,
size_t M, ///< number of subquantizers
size_t nbits, ///< number of bit per subvector index
int d_,
size_t M_, ///< number of subquantizers
size_t nbits_, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type,
int bbs)
: lsq(d, M, nbits, search_type) {
init(&lsq, metric, bbs);
int bbs_)
: lsq(d_, M_, nbits_, search_type) {
init(&lsq, metric, bbs_);
}

IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
Expand All @@ -260,15 +260,15 @@ IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
**************************************************************************************/

IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t nsplits, ///< number of residual quantizers
size_t Msub, ///< number of subquantizers per RQ
size_t nbits, ///< number of bit per subvector index
size_t nbits_, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type,
int bbs)
: prq(d, nsplits, Msub, nbits, search_type) {
init(&prq, metric, bbs);
int bbs_)
: prq(d_, nsplits, Msub, nbits_, search_type) {
init(&prq, metric, bbs_);
}

IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {
Expand All @@ -281,15 +281,15 @@ IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {

IndexProductLocalSearchQuantizerFastScan::
IndexProductLocalSearchQuantizerFastScan(
int d, ///< dimensionality of the input vectors
int d_, ///< dimensionality of the input vectors
size_t nsplits, ///< number of local search quantizers
size_t Msub, ///< number of subquantizers per LSQ
size_t nbits, ///< number of bit per subvector index
size_t nbits_, ///< number of bit per subvector index
MetricType metric,
Search_type_t search_type,
int bbs)
: plsq(d, nsplits, Msub, nbits, search_type) {
init(&plsq, metric, bbs);
int bbs_)
: plsq(d_, nsplits, Msub, nbits_, search_type) {
init(&plsq, metric, bbs_);
}

IndexProductLocalSearchQuantizerFastScan::
Expand Down
2 changes: 1 addition & 1 deletion faiss/IndexBinaryFlat.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@

namespace faiss {

IndexBinaryFlat::IndexBinaryFlat(idx_t d) : IndexBinary(d) {}
IndexBinaryFlat::IndexBinaryFlat(idx_t d_) : IndexBinary(d_) {}

void IndexBinaryFlat::add(idx_t n, const uint8_t* x) {
xb.insert(xb.end(), x, x + n * code_size);
Expand Down
8 changes: 4 additions & 4 deletions faiss/IndexBinaryFromFloat.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,10 +18,10 @@ namespace faiss {

IndexBinaryFromFloat::IndexBinaryFromFloat() = default;

IndexBinaryFromFloat::IndexBinaryFromFloat(Index* index)
: IndexBinary(index->d), index(index), own_fields(false) {
is_trained = index->is_trained;
ntotal = index->ntotal;
IndexBinaryFromFloat::IndexBinaryFromFloat(Index* index_)
: IndexBinary(index_->d), index(index_), own_fields(false) {
is_trained = index_->is_trained;
ntotal = index_->ntotal;
}

IndexBinaryFromFloat::~IndexBinaryFromFloat() {
Expand Down
Loading
Loading