faiss 0.4.1 → 0.4.2

data/vendor/faiss/faiss/impl/mapped_io.cpp

@@ -6,15 +6,12 @@
  */
 
 #include <stdio.h>
-#include <string.h>
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__FreeBSD__)
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #elif defined(_WIN32)
 
@@ -30,7 +27,7 @@
 
 namespace faiss {
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__FreeBSD__)
 
 struct MmappedFileMappingOwner::PImpl {
     void* ptr = nullptr;
@@ -171,12 +168,12 @@ struct MmappedFileMappingOwner::PImpl {
         const int fd = _fileno(f);
         if (fd == -1) {
             // no good
-            FAISS_THROW_FMT("could not get a HANDLE");
+            FAISS_THROW_MSG("could not get a HANDLE");
         }
 
         HANDLE file_handle = (HANDLE)_get_osfhandle(fd);
         if (file_handle == INVALID_HANDLE_VALUE) {
-            FAISS_THROW_FMT("could not get an OS HANDLE");
+            FAISS_THROW_MSG("could not get an OS HANDLE");
         }
 
         // get the size of the file

data/vendor/faiss/faiss/impl/pq4_fast_scan.cpp

@@ -6,7 +6,6 @@
  */
 
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/platform_macros.h>
 #include <faiss/impl/pq4_fast_scan.h>
 #include <faiss/impl/simd_result_handlers.h>
 

data/vendor/faiss/faiss/impl/pq4_fast_scan_search_qbs.cpp

@@ -10,7 +10,6 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/LookupTableScaler.h>
 #include <faiss/impl/simd_result_handlers.h>
-#include <faiss/utils/simdlib.h>
 
 namespace faiss {
 

data/vendor/faiss/faiss/impl/residual_quantizer_encode_steps.cpp

@@ -292,8 +292,8 @@ void beam_search_encode_step(
                     cent_ids.data() + i * beam_size * new_beam_size;
 
             // here we could be a tad more efficient by merging sorted arrays
-            for (int i_2 = 0; i_2 < new_beam_size; i_2++) {
-                new_distances_i[i_2] = C::neutral();
+            for (int j = 0; j < new_beam_size; j++) {
+                new_distances_i[j] = C::neutral();
             }
             std::vector<int> perm(new_beam_size, -1);
             heap_addn<C>(
@@ -325,8 +325,8 @@ void beam_search_encode_step(
             const float* cent_distances_i =
                     cent_distances.data() + i * beam_size * K;
             // then we have to select the best results
-            for (int i_2 = 0; i_2 < new_beam_size; i_2++) {
-                new_distances_i[i_2] = C::neutral();
+            for (int j = 0; j < new_beam_size; j++) {
+                new_distances_i[j] = C::neutral();
             }
             std::vector<int> perm(new_beam_size, -1);
 
@@ -558,8 +558,8 @@ void beam_search_encode_step_tab(
         const float* cent_distances_i = cent_distances.data();
 
         // then we have to select the best results
-        for (int i_2 = 0; i_2 < new_beam_size; i_2++) {
-            new_distances_i[i_2] = C::neutral();
+        for (int j = 0; j < new_beam_size; j++) {
+            new_distances_i[j] = C::neutral();
         }
         std::vector<int> perm(new_beam_size, -1);
 

data/vendor/faiss/faiss/impl/zerocopy_io.cpp

@@ -10,7 +10,7 @@
 
 namespace faiss {
 
-ZeroCopyIOReader::ZeroCopyIOReader(uint8_t* data, size_t size)
+ZeroCopyIOReader::ZeroCopyIOReader(const uint8_t* data, size_t size)
         : data_(data), rp_(0), total_(size) {}
 
 ZeroCopyIOReader::~ZeroCopyIOReader() {}

data/vendor/faiss/faiss/impl/zerocopy_io.h

@@ -15,11 +15,11 @@ namespace faiss {
 
 // ZeroCopyIOReader just maps the data from a given pointer.
 struct ZeroCopyIOReader : public faiss::IOReader {
-    uint8_t* data_;
+    const uint8_t* data_;
     size_t rp_ = 0;
     size_t total_ = 0;
 
-    ZeroCopyIOReader(uint8_t* data, size_t size);
+    ZeroCopyIOReader(const uint8_t* data, size_t size);
     ~ZeroCopyIOReader();
 
     void reset();

data/vendor/faiss/faiss/index_factory.cpp

@@ -170,7 +170,7 @@ AdditiveQuantizer::Search_type_t aq_parse_search_type(
         return metric == METRIC_L2 ? AdditiveQuantizer::ST_decompress
                                    : AdditiveQuantizer::ST_LUT_nonorm;
     }
-    int pos = stok.rfind("_");
+    int pos = stok.rfind('_');
     return aq_search_type[stok.substr(pos)];
 }
 
@@ -311,7 +311,8 @@ IndexIVF* parse_IndexIVF(
         const std::string& code_string,
         std::unique_ptr<Index>& quantizer,
         size_t nlist,
-        MetricType mt) {
+        MetricType mt,
+        bool own_il) {
     std::smatch sm;
     auto match = [&sm, &code_string](const std::string pattern) {
         return re_match(code_string, pattern, sm);
@@ -320,18 +321,25 @@ IndexIVF* parse_IndexIVF(
     int d = quantizer->d;
 
     if (match("Flat")) {
-        return new IndexIVFFlat(get_q(), d, nlist, mt);
+        return new IndexIVFFlat(get_q(), d, nlist, mt, own_il);
     }
     if (match("FlatDedup")) {
-        return new IndexIVFFlatDedup(get_q(), d, nlist, mt);
+        return new IndexIVFFlatDedup(get_q(), d, nlist, mt, own_il);
     }
     if (match(sq_pattern)) {
         return new IndexIVFScalarQuantizer(
-                get_q(), d, nlist, sq_types[sm[1].str()], mt);
+                get_q(),
+                d,
+                nlist,
+                sq_types[sm[1].str()],
+                mt,
+                /*by_residual=*/true,
+                own_il);
     }
     if (match("PQ([0-9]+)(x[0-9]+)?(np)?")) {
         int M = mres_to_int(sm[1]), nbit = mres_to_int(sm[2], 8, 1);
-        IndexIVFPQ* index_ivf = new IndexIVFPQ(get_q(), d, nlist, M, nbit, mt);
+        IndexIVFPQ* index_ivf =
+                new IndexIVFPQ(get_q(), d, nlist, M, nbit, mt, own_il);
         index_ivf->do_polysemous_training = sm[3].str() != "np";
         return index_ivf;
     }
@@ -340,13 +348,13 @@ IndexIVF* parse_IndexIVF(
                 mt == METRIC_L2,
                 "IVFPQR not implemented for inner product search");
         int M1 = mres_to_int(sm[1]), M2 = mres_to_int(sm[2]);
-        return new IndexIVFPQR(get_q(), d, nlist, M1, 8, M2, 8);
+        return new IndexIVFPQR(get_q(), d, nlist, M1, 8, M2, 8, own_il);
     }
     if (match("PQ([0-9]+)x4fs(r?)(_[0-9]+)?")) {
         int M = mres_to_int(sm[1]);
         int bbs = mres_to_int(sm[3], 32, 1);
-        IndexIVFPQFastScan* index_ivf =
-                new IndexIVFPQFastScan(get_q(), d, nlist, M, 4, mt, bbs);
+        IndexIVFPQFastScan* index_ivf = new IndexIVFPQFastScan(
+                get_q(), d, nlist, M, 4, mt, bbs, own_il);
         index_ivf->by_residual = sm[2].str() == "r";
         return index_ivf;
     }
@@ -357,11 +365,11 @@ IndexIVF* parse_IndexIVF(
         IndexIVF* index_ivf;
         if (sm[1].str() == "RQ") {
             index_ivf = new IndexIVFResidualQuantizer(
-                    get_q(), d, nlist, nbits, mt, st);
+                    get_q(), d, nlist, nbits, mt, st, own_il);
         } else {
             FAISS_THROW_IF_NOT(nbits.size() > 0);
             index_ivf = new IndexIVFLocalSearchQuantizer(
-                    get_q(), d, nlist, nbits.size(), nbits[0], mt, st);
+                    get_q(), d, nlist, nbits.size(), nbits[0], mt, st, own_il);
         }
         return index_ivf;
     }
@@ -373,10 +381,10 @@ IndexIVF* parse_IndexIVF(
         IndexIVF* index_ivf;
         if (sm[1].str() == "PRQ") {
             index_ivf = new IndexIVFProductResidualQuantizer(
-                    get_q(), d, nlist, nsplits, Msub, nbit, mt, st);
+                    get_q(), d, nlist, nsplits, Msub, nbit, mt, st, own_il);
         } else {
             index_ivf = new IndexIVFProductLocalSearchQuantizer(
-                    get_q(), d, nlist, nsplits, Msub, nbit, mt, st);
+                    get_q(), d, nlist, nsplits, Msub, nbit, mt, st, own_il);
         }
         return index_ivf;
     }
@@ -387,10 +395,10 @@ IndexIVF* parse_IndexIVF(
         IndexIVFAdditiveQuantizerFastScan* index_ivf;
         if (sm[1].str() == "RQ") {
             index_ivf = new IndexIVFResidualQuantizerFastScan(
-                    get_q(), d, nlist, M, 4, mt, st, bbs);
+                    get_q(), d, nlist, M, 4, mt, st, bbs, own_il);
         } else {
             index_ivf = new IndexIVFLocalSearchQuantizerFastScan(
-                    get_q(), d, nlist, M, 4, mt, st, bbs);
+                    get_q(), d, nlist, M, 4, mt, st, bbs, own_il);
         }
         index_ivf->by_residual = (sm[3].str() == "r");
         return index_ivf;
@@ -404,10 +412,10 @@ IndexIVF* parse_IndexIVF(
         IndexIVFAdditiveQuantizerFastScan* index_ivf;
         if (sm[1].str() == "PRQ") {
             index_ivf = new IndexIVFProductResidualQuantizerFastScan(
-                    get_q(), d, nlist, nsplits, Msub, 4, mt, st, bbs);
+                    get_q(), d, nlist, nsplits, Msub, 4, mt, st, bbs, own_il);
         } else {
             index_ivf = new IndexIVFProductLocalSearchQuantizerFastScan(
-                    get_q(), d, nlist, nsplits, Msub, 4, mt, st, bbs);
+                    get_q(), d, nlist, nsplits, Msub, 4, mt, st, bbs, own_il);
         }
         index_ivf->by_residual = (sm[4].str() == "r");
         return index_ivf;
@@ -425,8 +433,8 @@ IndexIVF* parse_IndexIVF(
         // the rationale for -1e10 is that this corresponds to simple
         // thresholding
         float period = sm[3].length() > 0 ? std::stof(sm[3]) : -1e10;
-        IndexIVFSpectralHash* index_ivf =
-                new IndexIVFSpectralHash(get_q(), d, nlist, outdim, period);
+        IndexIVFSpectralHash* index_ivf = new IndexIVFSpectralHash(
+                get_q(), d, nlist, outdim, period, own_il);
         index_ivf->replace_vt(vt.release(), true);
         if (sm[4].length()) {
             std::string s = sm[4].str();
@@ -440,7 +448,7 @@ IndexIVF* parse_IndexIVF(
         return index_ivf;
     }
     if (match(rabitq_pattern)) {
-        return new IndexIVFRaBitQ(get_q(), d, nlist, mt);
+        return new IndexIVFRaBitQ(get_q(), d, nlist, mt, own_il);
     }
     return nullptr;
 }
@@ -677,7 +685,8 @@ Index* parse_other_indexes(
 std::unique_ptr<Index> index_factory_sub(
         int d,
         std::string description,
-        MetricType metric) {
+        MetricType metric,
+        bool own_invlists = true) {
     // handle composite indexes
 
     bool verbose = index_factory_verbose;
@@ -838,7 +847,7 @@ std::unique_ptr<Index> index_factory_sub(
 
     // IndexRowwiseMinMax, fp32 version
     if (description.compare(0, 7, "MinMax,") == 0) {
-        size_t comma = description.find(",");
+        size_t comma = description.find(',');
         std::string sub_index_string = description.substr(comma + 1);
         auto sub_index = index_factory_sub(d, sub_index_string, metric);
 
@@ -850,7 +859,7 @@ std::unique_ptr<Index> index_factory_sub(
 
     // IndexRowwiseMinMax, fp16 version
     if (description.compare(0, 11, "MinMaxFP16,") == 0) {
-        size_t comma = description.find(",");
+        size_t comma = description.find(',');
         std::string sub_index_string = description.substr(comma + 1);
         auto sub_index = index_factory_sub(d, sub_index_string, metric);
 
@@ -864,7 +873,7 @@ std::unique_ptr<Index> index_factory_sub(
     {
         size_t nlist;
         bool use_2layer;
-        size_t comma = description.find(",");
+        size_t comma = description.find(',');
         std::string coarse_string = description.substr(0, comma);
         // Match coarse quantizer part first
         std::unique_ptr<Index> quantizer(parse_coarse_quantizer(
@@ -894,8 +903,8 @@ std::unique_ptr<Index> index_factory_sub(
                 return std::unique_ptr<Index>(index_2l);
             }
 
-            IndexIVF* index_ivf =
-                    parse_IndexIVF(code_description, quantizer, nlist, metric);
+            IndexIVF* index_ivf = parse_IndexIVF(
+                    code_description, quantizer, nlist, metric, own_invlists);
 
             FAISS_THROW_IF_NOT_FMT(
                     index_ivf,
@@ -911,25 +920,32 @@ std::unique_ptr<Index> index_factory_sub(
 
 } // anonymous namespace
 
-Index* index_factory(int d, const char* description, MetricType metric) {
-    return index_factory_sub(d, description, metric).release();
+Index* index_factory(
+        int d,
+        const char* description,
+        MetricType metric,
+        bool own_invlists) {
+    return index_factory_sub(d, description, metric, own_invlists).release();
 }
 
-IndexBinary* index_binary_factory(int d, const char* description) {
+IndexBinary* index_binary_factory(
+        int d,
+        const char* description,
+        bool own_invlists) {
     IndexBinary* index = nullptr;
 
     int ncentroids = -1;
     int M, nhash, b;
 
     if (sscanf(description, "BIVF%d_HNSW%d", &ncentroids, &M) == 2) {
-        IndexBinaryIVF* index_ivf =
-                new IndexBinaryIVF(new IndexBinaryHNSW(d, M), d, ncentroids);
+        IndexBinaryIVF* index_ivf = new IndexBinaryIVF(
+                new IndexBinaryHNSW(d, M), d, ncentroids, own_invlists);
         index_ivf->own_fields = true;
         index = index_ivf;
 
     } else if (sscanf(description, "BIVF%d", &ncentroids) == 1) {
-        IndexBinaryIVF* index_ivf =
-                new IndexBinaryIVF(new IndexBinaryFlat(d), d, ncentroids);
+        IndexBinaryIVF* index_ivf = new IndexBinaryIVF(
+                new IndexBinaryFlat(d), d, ncentroids, own_invlists);
         index_ivf->own_fields = true;
         index = index_ivf;
 

data/vendor/faiss/faiss/index_factory.h

@@ -17,11 +17,17 @@ namespace faiss {
 Index* index_factory(
         int d,
         const char* description,
-        MetricType metric = METRIC_L2);
+        MetricType metric = METRIC_L2,
+        // Whether to maintain inverted list within faiss index (only applicable
+        // to IndexIVF*)
+        bool own_invlists = true);
 
 /// set to > 0 to get more logs from index_factory
 FAISS_API extern int index_factory_verbose;
 
-IndexBinary* index_binary_factory(int d, const char* description);
+IndexBinary* index_binary_factory(
+        int d,
+        const char* description,
+        bool own_invlists = true);
 
 } // namespace faiss

data/vendor/faiss/faiss/index_io.h

@@ -11,9 +11,6 @@
 #define FAISS_INDEX_IO_H
 
 #include <cstdio>
-#include <string>
-#include <typeinfo>
-#include <vector>
 
 /** I/O functions can read/write to a filename, a file handle or to an
  * object that abstracts the medium.

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -85,8 +85,9 @@ idx_t DirectMap::get(idx_t key) const {
 }
 
 void DirectMap::add_single_id(idx_t id, idx_t list_no, size_t offset) {
-    if (type == NoMap)
+    if (type == NoMap) {
         return;
+    }
 
     if (type == Array) {
         assert(id == array.size());

data/vendor/faiss/faiss/invlists/InvertedLists.cpp

@@ -280,8 +280,9 @@ size_t ArrayInvertedLists::add_entries(
         size_t n_entry,
         const idx_t* ids_in,
         const uint8_t* code) {
-    if (n_entry == 0)
+    if (n_entry == 0) {
         return 0;
+    }
     assert(list_no < nlist);
     size_t o = ids[list_no].size();
     ids[list_no].resize(o + n_entry);
@@ -526,8 +527,9 @@ void SliceInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
     std::vector<idx_t> translated_list_nos;
     for (int j = 0; j < nlist; j++) {
         idx_t list_no = list_nos[j];
-        if (list_no < 0)
+        if (list_no < 0) {
             continue;
+        }
         translated_list_nos.push_back(translate_list_no(this, list_no));
     }
     il->prefetch_lists(translated_list_nos.data(), translated_list_nos.size());
@@ -630,8 +632,9 @@ void VStackInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
     std::vector<int> n_per_il(ils.size(), 0);
     for (int j = 0; j < nlist; j++) {
         idx_t list_no = list_nos[j];
-        if (list_no < 0)
+        if (list_no < 0) {
             continue;
+        }
         int i = ilno[j] = translate_list_no(this, list_no);
         n_per_il[i]++;
     }
@@ -642,8 +645,9 @@ void VStackInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
     std::vector<idx_t> sorted_list_nos(cum_n_per_il.back());
     for (int j = 0; j < nlist; j++) {
         idx_t list_no = list_nos[j];
-        if (list_no < 0)
+        if (list_no < 0) {
             continue;
+        }
         int i = ilno[j];
         list_no -= cumsz[i];
         sorted_list_nos[cum_n_per_il[i]++] = list_no;
@@ -716,8 +720,9 @@ void MaskedInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
     std::vector<idx_t> list0, list1;
     for (int i = 0; i < nlist; i++) {
         idx_t list_no = list_nos[i];
-        if (list_no < 0)
+        if (list_no < 0) {
             continue;
+        }
         size_t sz = il0->list_size(list_no);
         (sz ? list0 : list1).push_back(list_no);
     }
@@ -782,8 +787,9 @@ void StopWordsInvertedLists::prefetch_lists(const idx_t* list_nos, int nlist)
     std::vector<idx_t> list0;
     for (int i = 0; i < nlist; i++) {
         idx_t list_no = list_nos[i];
-        if (list_no < 0)
+        if (list_no < 0) {
             continue;
+        }
         if (il0->list_size(list_no) < maxsize) {
             list0.push_back(list_no);
         }

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.cpp

@@ -148,8 +148,9 @@ struct OnDiskInvertedLists::OngoingPrefetch {
 
         bool one_list() {
             idx_t list_no = pf->get_next_list();
-            if (list_no == -1)
+            if (list_no == -1) {
                 return false;
+            }
             const OnDiskInvertedLists* od = pf->od;
             od->locks->lock_1(list_no);
             size_t n = od->list_size(list_no);
@@ -195,8 +196,9 @@ struct OnDiskInvertedLists::OngoingPrefetch {
     static void* prefetch_list(void* arg) {
         Thread* th = static_cast<Thread*>(arg);
 
-        while (th->one_list())
+        while (th->one_list()) {
             ;
+        }
 
         return nullptr;
     }
@@ -404,8 +406,9 @@ void OnDiskInvertedLists::update_entries(
         const idx_t* ids_in,
         const uint8_t* codes_in) {
     FAISS_THROW_IF_NOT(!read_only);
-    if (n_entry == 0)
+    if (n_entry == 0) {
         return;
+    }
     [[maybe_unused]] const List& l = lists[list_no];
     assert(n_entry + offset <= l.size);
     idx_t* ids = const_cast<idx_t*>(get_ids(list_no));
@@ -515,8 +518,9 @@ size_t OnDiskInvertedLists::allocate_slot(size_t capacity) {
 
 void OnDiskInvertedLists::free_slot(size_t offset, size_t capacity) {
     // should hold lock2
-    if (capacity == 0)
+    if (capacity == 0) {
         return;
+    }
 
     auto it = slots.begin();
     while (it != slots.end() && it->offset <= offset) {

data/vendor/faiss/faiss/utils/Heap.cpp

@@ -17,21 +17,24 @@ namespace faiss {
 template <typename C>
 void HeapArray<C>::heapify() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++)
+    for (int64_t j = 0; j < nh; j++) {
         heap_heapify<C>(k, val + j * k, ids + j * k);
+    }
 }
 
 template <typename C>
 void HeapArray<C>::reorder() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++)
+    for (int64_t j = 0; j < nh; j++) {
         heap_reorder<C>(k, val + j * k, ids + j * k);
+    }
 }
 
 template <typename C>
 void HeapArray<C>::addn(size_t nj, const T* vin, TI j0, size_t i0, int64_t ni) {
-    if (ni == -1)
+    if (ni == -1) {
         ni = nh;
+    }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
     for (int64_t i = i0; i < i0 + ni; i++) {
@@ -60,8 +63,9 @@ void HeapArray<C>::addn_with_ids(
         addn(nj, vin, 0, i0, ni);
         return;
     }
-    if (ni == -1)
+    if (ni == -1) {
         ni = nh;
+    }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
     for (int64_t i = i0; i < i0 + ni; i++) {
@@ -115,19 +119,22 @@ void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
         int64_t imin = -1;
         typename C::T xval = C::Crev::neutral();
         const typename C::T* x_ = val + j * k;
-        for (size_t i = 0; i < k; i++)
+        for (size_t i = 0; i < k; i++) {
             if (C::cmp(x_[i], xval)) {
                 xval = x_[i];
                 imin = i;
             }
-        if (out_val)
+        }
+        if (out_val) {
             out_val[j] = xval;
+        }
 
         if (out_ids) {
-            if (ids && imin != -1)
+            if (ids && imin != -1) {
                 out_ids[j] = ids[j * k + imin];
-            else
+            } else {
                 out_ids[j] = imin;
+            }
         }
     }
 }

data/vendor/faiss/faiss/utils/Heap.h

@@ -53,8 +53,9 @@ inline void heap_pop(size_t k, typename C::T* bh_val, typename C::TI* bh_ids) {
     while (1) {
         i1 = i << 1;
         i2 = i1 + 1;
-        if (i1 > k)
+        if (i1 > k) {
             break;
+        }
         if ((i2 == k + 1) ||
             C::cmp2(bh_val[i1], bh_val[i2], bh_ids[i1], bh_ids[i2])) {
             if (C::cmp2(val, bh_val[i1], id, bh_ids[i1])) {
@@ -220,8 +221,9 @@ inline void heap_pop(size_t k, std::pair<typename C::T, typename C::TI>* bh) {
     while (1) {
         i1 = i << 1;
         i2 = i1 + 1;
-        if (i1 > k)
+        if (i1 > k) {
             break;
+        }
         if ((i2 == k + 1) ||
             C::cmp2(bh[i1].first, bh[i2].first, bh[i1].second, bh[i2].second)) {
             if (C::cmp2(val, bh[i1].first, id, bh[i1].second)) {
@@ -320,15 +322,18 @@ inline void heap_heapify(
         const typename C::T* x = nullptr,
         const typename C::TI* ids = nullptr,
         size_t k0 = 0) {
-    if (k0 > 0)
+    if (k0 > 0) {
         assert(x);
+    }
 
     if (ids) {
-        for (size_t i = 0; i < k0; i++)
+        for (size_t i = 0; i < k0; i++) {
             heap_push<C>(i + 1, bh_val, bh_ids, x[i], ids[i]);
+        }
     } else {
-        for (size_t i = 0; i < k0; i++)
+        for (size_t i = 0; i < k0; i++) {
             heap_push<C>(i + 1, bh_val, bh_ids, x[i], i);
+        }
     }
 
     for (size_t i = k0; i < k; i++) {
@@ -373,18 +378,19 @@ inline void heap_addn(
         const typename C::TI* ids,
         size_t n) {
     size_t i;
-    if (ids)
+    if (ids) {
         for (i = 0; i < n; i++) {
             if (C::cmp(bh_val[0], x[i])) {
                 heap_replace_top<C>(k, bh_val, bh_ids, x[i], ids[i]);
             }
         }
-    else
+    } else {
         for (i = 0; i < n; i++) {
             if (C::cmp(bh_val[0], x[i])) {
                 heap_replace_top<C>(k, bh_val, bh_ids, x[i], i);
             }
         }
+    }
 }
 
 /* Partial instanciation for heaps with TI = int64_t */
@@ -433,8 +439,9 @@ inline size_t heap_reorder(
         heap_pop<C>(k - i, bh_val, bh_ids);
         bh_val[k - ii - 1] = val;
         bh_ids[k - ii - 1] = id;
-        if (id != -1)
+        if (id != -1) {
             ii++;
+        }
     }
     /* Count the number of elements which are effectively returned */
     size_t nel = ii;
@@ -573,17 +580,20 @@ inline void indirect_heap_pop(
     while (1) {
         size_t i1 = i << 1;
         size_t i2 = i1 + 1;
-        if (i1 > k)
+        if (i1 > k) {
             break;
+        }
         typename C::TI id1 = bh_ids[i1], id2 = bh_ids[i2];
         if (i2 == k + 1 || C::cmp(bh_val[id1], bh_val[id2])) {
-            if (C::cmp(val, bh_val[id1]))
+            if (C::cmp(val, bh_val[id1])) {
                 break;
+            }
             bh_ids[i] = id1;
             i = i1;
         } else {
-            if (C::cmp(val, bh_val[id2]))
+            if (C::cmp(val, bh_val[id2])) {
                 break;
+            }
             bh_ids[i] = id2;
             i = i2;
         }
@@ -602,8 +612,9 @@ inline void indirect_heap_push(
     size_t i = k;
     while (i > 1) {
         size_t i_father = i >> 1;
-        if (!C::cmp(val, bh_val[bh_ids[i_father]]))
+        if (!C::cmp(val, bh_val[bh_ids[i_father]])) {
             break;
+        }
         bh_ids[i] = bh_ids[i_father];
         i = i_father;
     }