faiss 0.6.0 → 0.6.1

data/vendor/faiss/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);
@@ -165,7 +165,7 @@ double SimulatedAnnealingOptimizer::optimize(int* perm) {
  ****************************************************/
 
 static inline int hamming_dis(uint64_t a, uint64_t b) {
-    return __builtin_popcountl(a ^ b);
+    return popcount64(a ^ b);
 }
 
 namespace {
@@ -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,14 @@ void PolysemousTraining::optimize_reproduce_distances(
 
         if (log_pattern.size()) {
             char fname[256];
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
             snprintf(fname, 256, log_pattern.c_str(), m);
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
             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 +879,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 +908,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 +942,14 @@ void PolysemousTraining::optimize_ranking(
 
         if (log_pattern.size()) {
             char fname[256];
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
             snprintf(fname, 256, log_pattern.c_str(), m);
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
             printf("opening log file %s\n", fname);
             optim.logfile = fopen(fname, "w");
             FAISS_THROW_IF_NOT_FMT(
@@ -957,11 +971,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]));

data/vendor/faiss/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;
 

data/vendor/faiss/faiss/impl/ProductAdditiveQuantizer.cpp

@@ -42,22 +42,22 @@ int sgemm_(
 namespace faiss {
 
 ProductAdditiveQuantizer::ProductAdditiveQuantizer(
-        size_t d,
+        size_t d_,
         const std::vector<AdditiveQuantizer*>& aqs,
-        Search_type_t search_type) {
-    init(d, aqs, search_type);
+        Search_type_t search_type_) {
+    init(d_, aqs, search_type_);
 }
 
 ProductAdditiveQuantizer::ProductAdditiveQuantizer()
         : ProductAdditiveQuantizer(0, {}) {}
 
 void ProductAdditiveQuantizer::init(
-        size_t d,
+        size_t d_in,
         const std::vector<AdditiveQuantizer*>& aqs,
-        Search_type_t search_type) {
+        Search_type_t search_type_in) {
     // AdditiveQuantizer constructor
-    this->d = d;
-    this->search_type = search_type;
+    this->d = d_in;
+    this->search_type = search_type_in;
     M = 0;
     for (const auto& q : aqs) {
         M += q->M;
@@ -98,7 +98,7 @@ void ProductAdditiveQuantizer::train(size_t n, const float* x) {
         xt.resize(q->d * n);
 
 #pragma omp parallel for if (n > 1000)
-        for (idx_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(n); i++) {
             memcpy(xt.data() + i * q->d,
                    x + i * d + offset_d,
                    q->d * sizeof(*x));
@@ -153,7 +153,7 @@ void ProductAdditiveQuantizer::compute_unpacked_codes(
         const float* x,
         int32_t* unpacked_codes,
         size_t n,
-        const float* centroids) const {
+        const float* /*centroids*/) const {
     /// TODO: actually we do not need to unpack and pack
     size_t offset_d = 0, offset_m = 0;
     std::vector<float> xsub;
@@ -165,7 +165,7 @@ void ProductAdditiveQuantizer::compute_unpacked_codes(
         codes.resize(n * q->code_size);
 
 #pragma omp parallel for if (n > 1000)
-        for (idx_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(n); i++) {
             memcpy(xsub.data() + i * q->d,
                    x + i * d + offset_d,
                    q->d * sizeof(float));
@@ -175,7 +175,7 @@ void ProductAdditiveQuantizer::compute_unpacked_codes(
 
         // unpack
 #pragma omp parallel for if (n > 1000)
-        for (idx_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < static_cast<idx_t>(n); i++) {
             uint8_t* code = codes.data() + i * q->code_size;
             BitstringReader bsr(code, q->code_size);
 
@@ -204,7 +204,7 @@ void ProductAdditiveQuantizer::decode_unpacked(
 
     // product additive quantizer decoding
 #pragma omp parallel for if (n > 1000)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(n); i++) {
         const int32_t* codesi = codes + i * ld_codes;
 
         size_t offset_m = 0, offset_d = 0;
@@ -212,7 +212,7 @@ void ProductAdditiveQuantizer::decode_unpacked(
             const auto q = quantizers[s];
             float* xi = x + i * d + offset_d;
 
-            for (int m = 0; m < q->M; m++) {
+            for (size_t m = 0; m < q->M; m++) {
                 int idx = codesi[offset_m + m];
                 const float* c = codebooks.data() +
                         q->d * (codebook_offsets[offset_m + m] + idx);
@@ -235,7 +235,7 @@ void ProductAdditiveQuantizer::decode(const uint8_t* codes, float* x, size_t n)
             is_trained, "The product additive quantizer is not trained yet.");
 
 #pragma omp parallel for if (n > 1000)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(n); i++) {
         BitstringReader bsr(codes + i * code_size, code_size);
 
         size_t offset_m = 0, offset_d = 0;
@@ -243,7 +243,7 @@ void ProductAdditiveQuantizer::decode(const uint8_t* codes, float* x, size_t n)
             const auto q = quantizers[s];
             float* xi = x + i * d + offset_d;
 
-            for (int m = 0; m < q->M; m++) {
+            for (size_t m = 0; m < q->M; m++) {
                 int idx = bsr.read(q->nbits[m]);
                 const float* c = codebooks.data() +
                         q->d * (codebook_offsets[offset_m + m] + idx);
@@ -315,24 +315,24 @@ void ProductAdditiveQuantizer::compute_LUT(
  ************************************/
 
 ProductLocalSearchQuantizer::ProductLocalSearchQuantizer(
-        size_t d,
-        size_t nsplits,
+        size_t d_,
+        size_t nsplits_,
         size_t Msub,
-        size_t nbits,
-        Search_type_t search_type) {
+        size_t nbits_,
+        Search_type_t search_type_) {
     std::vector<AdditiveQuantizer*> aqs;
 
-    if (nsplits > 0) {
-        FAISS_THROW_IF_NOT(d % nsplits == 0);
-        size_t dsub = d / nsplits;
+    if (nsplits_ > 0) {
+        FAISS_THROW_IF_NOT(d_ % nsplits_ == 0);
+        size_t dsub = d_ / nsplits_;
 
-        for (size_t i = 0; i < nsplits; i++) {
+        for (size_t i = 0; i < nsplits_; i++) {
             auto lsq =
-                    new LocalSearchQuantizer(dsub, Msub, nbits, ST_decompress);
+                    new LocalSearchQuantizer(dsub, Msub, nbits_, ST_decompress);
             aqs.push_back(lsq);
         }
     }
-    init(d, aqs, search_type);
+    init(d_, aqs, search_type_);
     for (auto& q : aqs) {
         delete q;
     }
@@ -346,23 +346,23 @@ ProductLocalSearchQuantizer::ProductLocalSearchQuantizer()
  ************************************/
 
 ProductResidualQuantizer::ProductResidualQuantizer(
-        size_t d,
-        size_t nsplits,
+        size_t d_,
+        size_t nsplits_,
         size_t Msub,
-        size_t nbits,
-        Search_type_t search_type) {
+        size_t nbits_,
+        Search_type_t search_type_) {
     std::vector<AdditiveQuantizer*> aqs;
 
-    if (nsplits > 0) {
-        FAISS_THROW_IF_NOT(d % nsplits == 0);
-        size_t dsub = d / nsplits;
+    if (nsplits_ > 0) {
+        FAISS_THROW_IF_NOT(d_ % nsplits_ == 0);
+        size_t dsub = d_ / nsplits_;
 
-        for (size_t i = 0; i < nsplits; i++) {
-            auto rq = new ResidualQuantizer(dsub, Msub, nbits, ST_decompress);
+        for (size_t i = 0; i < nsplits_; i++) {
+            auto rq = new ResidualQuantizer(dsub, Msub, nbits_, ST_decompress);
             aqs.push_back(rq);
         }
     }
-    init(d, aqs, search_type);
+    init(d_, aqs, search_type_);
     for (auto& q : aqs) {
         delete q;
     }

data/vendor/faiss/faiss/impl/ProductQuantizer-inl.h

@@ -10,10 +10,10 @@
 namespace faiss {
 
 inline PQEncoderGeneric::PQEncoderGeneric(
-        uint8_t* code,
-        int nbits,
-        uint8_t offset)
-        : code(code), offset(offset), nbits(nbits), reg(0) {
+        uint8_t* code_in,
+        int nbits_in,
+        uint8_t offset_in)
+        : code(code_in), offset(offset_in), nbits(nbits_in), reg(0) {
     assert(nbits <= 64);
     if (offset > 0) {
         reg = (*code & ((1 << offset) - 1));
@@ -45,28 +45,30 @@ inline PQEncoderGeneric::~PQEncoderGeneric() {
     }
 }
 
-inline PQEncoder8::PQEncoder8(uint8_t* code, int nbits) : code(code) {
-    assert(8 == nbits);
+inline PQEncoder8::PQEncoder8(uint8_t* code_in, int nbits_in) : code(code_in) {
+    assert(8 == nbits_in);
+    (void)nbits_in;
 }
 
 inline void PQEncoder8::encode(uint64_t x) {
     *code++ = (uint8_t)x;
 }
 
-inline PQEncoder16::PQEncoder16(uint8_t* code, int nbits)
-        : code((uint16_t*)code) {
-    assert(16 == nbits);
+inline PQEncoder16::PQEncoder16(uint8_t* code_in, int nbits_in)
+        : code((uint16_t*)code_in) {
+    assert(16 == nbits_in);
+    (void)nbits_in;
 }
 
 inline void PQEncoder16::encode(uint64_t x) {
     *code++ = (uint16_t)x;
 }
 
-inline PQDecoderGeneric::PQDecoderGeneric(const uint8_t* code, int nbits)
-        : code(code),
+inline PQDecoderGeneric::PQDecoderGeneric(const uint8_t* code_in, int nbits_in)
+        : code(code_in),
           offset(0),
-          nbits(nbits),
-          mask((1ull << nbits) - 1),
+          nbits(nbits_in),
+          mask((1ull << nbits_in) - 1),
           reg(0) {
     assert(nbits <= 64);
 }
@@ -98,17 +100,20 @@ inline uint64_t PQDecoderGeneric::decode() {
     return c & mask;
 }
 
-inline PQDecoder8::PQDecoder8(const uint8_t* code, int nbits_in) : code(code) {
+inline PQDecoder8::PQDecoder8(const uint8_t* code_in, int nbits_in)
+        : code(code_in) {
     assert(8 == nbits_in);
+    (void)nbits_in;
 }
 
 inline uint64_t PQDecoder8::decode() {
     return (uint64_t)(*code++);
 }
 
-inline PQDecoder16::PQDecoder16(const uint8_t* code, int nbits_in)
-        : code((uint16_t*)code) {
+inline PQDecoder16::PQDecoder16(const uint8_t* code_in, int nbits_in)
+        : code((uint16_t*)code_in) {
     assert(16 == nbits_in);
+    (void)nbits_in;
 }
 
 inline uint64_t PQDecoder16::decode() {

data/vendor/faiss/faiss/impl/ProductQuantizer.cpp

@@ -48,8 +48,8 @@ namespace faiss {
  * PQ implementation
  *********************************************/
 
-ProductQuantizer::ProductQuantizer(size_t d, size_t M, size_t nbits)
-        : Quantizer(d, 0), M(M), nbits(nbits), assign_index(nullptr) {
+ProductQuantizer::ProductQuantizer(size_t d_in, size_t M_in, size_t nbits_in)
+        : Quantizer(d_in, 0), M(M_in), nbits(nbits_in), assign_index(nullptr) {
     set_derived_values();
 }
 
@@ -139,8 +139,8 @@ void ProductQuantizer::train(size_t n, const float* x) {
         }
 
         std::unique_ptr<float[]> xslice(new float[n * dsub]);
-        for (int m = 0; m < M; m++) {
-            for (int j = 0; j < n; j++)
+        for (size_t m = 0; m < M; m++) {
+            for (size_t j = 0; j < n; j++)
                 memcpy(xslice.get() + j * dsub,
                        x + j * d + m * dsub,
                        dsub * sizeof(float));
@@ -179,7 +179,7 @@ void ProductQuantizer::train(size_t n, const float* x) {
 
             if (verbose) {
                 clus.verbose = true;
-                printf("Training PQ slice %d/%zd\n", m, M);
+                printf("Training PQ slice %zd/%zd\n", m, M);
             }
             IndexFlatL2 index(dsub);
             clus.train(n, xslice.get(), assign_index ? *assign_index : index);
@@ -197,7 +197,7 @@ void ProductQuantizer::train(size_t n, const float* x) {
         IndexFlatL2 index(dsub);
 
         clus.train(n * M, x, assign_index ? *assign_index : index);
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             set_params(clus.centroids.data(), m);
         }
     }
@@ -322,8 +322,9 @@ void ProductQuantizer::decode(const uint8_t* code, float* x) const {
 }
 
 void ProductQuantizer::decode(const uint8_t* code, float* x, size_t n) const {
+    int64_t n_signed = n;
 #pragma omp parallel for if (n > 100)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < n_signed; i++) {
         this->decode(code + code_size * i, x + d * i);
     }
 }
@@ -353,7 +354,8 @@ void ProductQuantizer::compute_codes_with_assign_index(
         const float* x,
         uint8_t* codes,
         size_t n) {
-    FAISS_THROW_IF_NOT(assign_index && assign_index->d == dsub);
+    FAISS_THROW_IF_NOT(
+            assign_index && static_cast<size_t>(assign_index->d) == dsub);
 
     for (size_t m = 0; m < M; m++) {
         assign_index->reset();
@@ -415,10 +417,11 @@ void ProductQuantizer::compute_codes(const float* x, uint8_t* codes, size_t n)
         return;
     }
 
+    int64_t n_signed = n;
     if (dsub < 16) { // simple direct computation
 
 #pragma omp parallel for
-        for (int64_t i = 0; i < n; i++)
+        for (int64_t i = 0; i < n_signed; i++)
             compute_code(x + i * d, codes + i * code_size);
 
     } else { // worthwhile to use BLAS
@@ -426,7 +429,7 @@ void ProductQuantizer::compute_codes(const float* x, uint8_t* codes, size_t n)
         compute_distance_tables(n, x, dis_tables.get());
 
 #pragma omp parallel for
-        for (int64_t i = 0; i < n; i++) {
+        for (int64_t i = 0; i < n_signed; i++) {
             uint8_t* code = codes + i * code_size;
             const float* tab = dis_tables.get() + i * ksub * M;
             compute_code_from_distance_table(tab, code);
@@ -482,7 +485,8 @@ void ProductQuantizer::compute_distance_tables(
         size_t nx,
         const float* x,
         float* dis_tables) const {
-#if defined(__AVX2__) || defined(__aarch64__)
+    int64_t nx_signed = nx;
+#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON)
     if (dsub == 2 && nbits < 8) { // interesting for a narrow range of settings
         compute_PQ_dis_tables_dsub2(
                 d, ksub, centroids.data(), nx, x, false, dis_tables);
@@ -491,13 +495,13 @@ void ProductQuantizer::compute_distance_tables(
             if (dsub < 16) {
 
 #pragma omp parallel for if (nx > 1)
-        for (int64_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < nx_signed; i++) {
             compute_distance_table(x + i * d, dis_tables + i * ksub * M);
         }
 
     } else { // use BLAS
 
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             pairwise_L2sqr(
                     dsub,
                     nx,
@@ -516,7 +520,8 @@ void ProductQuantizer::compute_inner_prod_tables(
         size_t nx,
         const float* x,
         float* dis_tables) const {
-#if defined(__AVX2__) || defined(__aarch64__)
+    int64_t nx_signed = nx;
+#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON)
     if (dsub == 2 && nbits < 8) {
         compute_PQ_dis_tables_dsub2(
                 d, ksub, centroids.data(), nx, x, true, dis_tables);
@@ -525,14 +530,14 @@ void ProductQuantizer::compute_inner_prod_tables(
             if (dsub < 16) {
 
 #pragma omp parallel for if (nx > 1)
-        for (int64_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < nx_signed; i++) {
             compute_inner_prod_table(x + i * d, dis_tables + i * ksub * M);
         }
 
     } else { // use BLAS
 
         // compute distance tables
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             FINTEGER ldc = ksub * M, nxi = nx, ksubi = ksub, dsubi = dsub,
                      di = d;
             float one = 1.0, zero = 0;
@@ -576,7 +581,7 @@ void pq_estimators_from_tables_Mmul4(
         float dis = 0;
         const float* dt = dis_table;
 
-        for (size_t m = 0; m < M; m += 4) {
+        for (int m = 0; m < M; m += 4) {
             float dism = 0;
             dism = dt[*codes++];
             dt += ksub;
@@ -648,7 +653,7 @@ void pq_estimators_from_tables(
     for (size_t j = 0; j < ncodes; j++) {
         float dis = 0;
         const float* __restrict dt = dis_table;
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             dis += dt[*codes++];
             dt += ksub;
         }
@@ -696,10 +701,11 @@ void pq_knn_search_with_tables(
         HeapArray<C>* res,
         bool init_finalize_heap) {
     size_t k = res->k, nx = res->nh;
+    int64_t nx_signed = nx;
     size_t ksub = pq.ksub, M = pq.M;
 
 #pragma omp parallel for if (nx > 1)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < nx_signed; i++) {
         /* query preparation for asymmetric search: compute look-up tables */
         const float* dis_table = dis_tables + i * ksub * M;
 
@@ -797,7 +803,7 @@ void ProductQuantizer::compute_sdc_table() {
     if (dsub < 4) {
         with_simd_level([&]<SIMDLevel SL>() {
 #pragma omp parallel for
-            for (int mk = 0; mk < M * ksub; mk++) {
+            for (int64_t mk = 0; mk < static_cast<int64_t>(M * ksub); mk++) {
                 // allow omp to schedule in a more fine-grained way
                 // `collapse` is not supported in OpenMP 2.x
                 int m = mk / ksub;
@@ -812,7 +818,7 @@ void ProductQuantizer::compute_sdc_table() {
         // NOTE: it would disable the omp loop in pairwise_L2sqr
         // but still accelerate especially when M >= 4
 #pragma omp parallel for
-        for (int m = 0; m < M; m++) {
+        for (int64_t m = 0; m < static_cast<int64_t>(M); m++) {
             const float* cents = centroids.data() + m * ksub * dsub;
             float* dis_tab = sdc_table.data() + m * ksub * ksub;
             pairwise_L2sqr(
@@ -831,9 +837,10 @@ void ProductQuantizer::search_sdc(
     FAISS_THROW_IF_NOT(sdc_table.size() == M * ksub * ksub);
     FAISS_THROW_IF_NOT(nbits == 8);
     size_t k = res->k;
+    int64_t nq_signed = nq;
 
 #pragma omp parallel for
-    for (int64_t i = 0; i < nq; i++) {
+    for (int64_t i = 0; i < nq_signed; i++) {
         /* Compute distances and keep smallest values */
         idx_t* heap_ids = res->ids + i * k;
         float* heap_dis = res->val + i * k;
@@ -846,7 +853,7 @@ void ProductQuantizer::search_sdc(
         for (size_t j = 0; j < nb; j++) {
             float dis = 0;
             const float* tab = sdc_table.data();
-            for (int m = 0; m < M; m++) {
+            for (size_t m = 0; m < M; m++) {
                 dis += tab[bcode[m] + qcode[m] * ksub];
                 tab += ksub * ksub;
             }

data/vendor/faiss/faiss/impl/Quantizer.h

@@ -16,8 +16,8 @@ struct Quantizer {
     size_t d;         ///< size of the input vectors
     size_t code_size; ///< bytes per indexed vector
 
-    explicit Quantizer(size_t d = 0, size_t code_size = 0)
-            : d(d), code_size(code_size) {}
+    explicit Quantizer(size_t d_in = 0, size_t code_size_in = 0)
+            : d(d_in), code_size(code_size_in) {}
 
     /** Train the quantizer
      *