faiss 0.4.1 → 0.4.2

data/vendor/faiss/faiss/gpu/GpuAutoTune.cpp

@@ -41,21 +41,25 @@ void GpuParameterSpace::initialize(const Index* index) {
         return;
     }
     if (DC(IndexReplicas)) {
-        if (ix->count() == 0)
+        if (ix->count() == 0) {
             return;
+        }
         index = ix->at(0);
     }
     if (DC(IndexShards)) {
-        if (ix->count() == 0)
+        if (ix->count() == 0) {
             return;
+        }
         index = ix->at(0);
     }
     if (DC(GpuIndexIVF)) {
         ParameterRange& pr = add_range("nprobe");
         for (int i = 0; i < 12; i++) {
             size_t nprobe = 1 << i;
-            if (nprobe >= ix->getNumLists() || nprobe > getMaxKSelection())
+            if (nprobe >= ix->getNumLists() ||
+                nprobe > getMaxKSelection(false)) {
                 break;
+            }
             pr.values.push_back(nprobe);
         }
 
@@ -79,8 +83,9 @@ void GpuParameterSpace::set_index_parameter(
         const std::string& name,
         double val) const {
     if (DC(IndexReplicas)) {
-        for (int i = 0; i < ix->count(); i++)
+        for (int i = 0; i < ix->count(); i++) {
             set_index_parameter(ix->at(i), name, val);
+        }
         return;
     }
     if (name == "nprobe") {

data/vendor/faiss/faiss/gpu/GpuCloner.cpp

@@ -15,6 +15,7 @@
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/IndexFlat.h>
 #if defined USE_NVIDIA_CUVS
+#include <faiss/IndexBinaryHNSW.h>
 #include <faiss/IndexHNSW.h>
 #endif
 #include <faiss/IndexIVF.h>
@@ -28,14 +29,13 @@
 #include <faiss/gpu/GpuIndex.h>
 #include <faiss/gpu/GpuIndexBinaryFlat.h>
 #if defined USE_NVIDIA_CUVS
+#include <faiss/gpu/GpuIndexBinaryCagra.h>
 #include <faiss/gpu/GpuIndexCagra.h>
 #endif
 #include <faiss/gpu/GpuIndexFlat.h>
 #include <faiss/gpu/GpuIndexIVFFlat.h>
 #include <faiss/gpu/GpuIndexIVFPQ.h>
 #include <faiss/gpu/GpuIndexIVFScalarQuantizer.h>
-#include <faiss/gpu/utils/DeviceUtils.h>
-#include <faiss/impl/FaissAssert.h>
 #include <faiss/index_io.h>
 
 namespace faiss {
@@ -95,6 +95,9 @@ Index* ToCPUCloner::clone_Index(const Index* index) {
 #if defined USE_NVIDIA_CUVS
     else if (auto icg = dynamic_cast<const GpuIndexCagra*>(index)) {
         IndexHNSWCagra* res = new IndexHNSWCagra();
+        if (icg->get_numeric_type() != faiss::NumericType::Float32) {
+            res->base_level_only = true;
+        }
         icg->copyTo(res);
         return res;
     }
@@ -236,7 +239,7 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
         config.device = device;
         GpuIndexCagra* res =
                 new GpuIndexCagra(provider, icg->d, icg->metric_type, config);
-        res->copyFrom(icg);
+        res->copyFromEx(icg, icg->get_numeric_type());
         return res;
     }
 #endif
@@ -290,14 +293,16 @@ void ToGpuClonerMultiple::copy_ivf_shard(
         idx_t i0 = i * index_ivf->ntotal / n;
         idx_t i1 = (i + 1) * index_ivf->ntotal / n;
 
-        if (verbose)
+        if (verbose) {
             printf("IndexShards shard %ld indices %ld:%ld\n", i, i0, i1);
+        }
         index_ivf->copy_subset_to(
                 *idx2, InvertedLists::SUBSET_TYPE_ID_RANGE, i0, i1);
         FAISS_ASSERT(idx2->ntotal == i1 - i0);
     } else if (shard_type == 1) {
-        if (verbose)
+        if (verbose) {
             printf("IndexShards shard %ld select modulo %ld = %ld\n", i, n, i);
+        }
         index_ivf->copy_subset_to(
                 *idx2, InvertedLists::SUBSET_TYPE_ID_MOD, n, i);
     } else if (shard_type == 4) {
@@ -527,7 +532,15 @@ faiss::IndexBinary* index_binary_gpu_to_cpu(
         IndexBinaryFlat* ret = new IndexBinaryFlat();
         ii->copyTo(ret);
         return ret;
-    } else {
+    }
+#if defined USE_NVIDIA_CUVS
+    else if (auto ii = dynamic_cast<const GpuIndexBinaryCagra*>(gpu_index)) {
+        IndexBinaryHNSWCagra* ret = new IndexBinaryHNSWCagra();
+        ii->copyTo(ret);
+        return ret;
+    }
+#endif
+    else {
         FAISS_THROW_MSG("cannot clone this type of index");
     }
 }
@@ -540,11 +553,20 @@ faiss::IndexBinary* index_binary_cpu_to_gpu(
     if (auto ii = dynamic_cast<const IndexBinaryFlat*>(index)) {
         GpuIndexBinaryFlatConfig config;
         config.device = device;
-        if (options) {
-            config.use_cuvs = options->use_cuvs;
-        }
         return new GpuIndexBinaryFlat(provider, ii, config);
-    } else {
+    }
+#if defined USE_NVIDIA_CUVS
+    else if (
+            auto ii = dynamic_cast<const faiss::IndexBinaryHNSWCagra*>(index)) {
+        GpuIndexCagraConfig config;
+        config.device = device;
+        GpuIndexBinaryCagra* res =
+                new GpuIndexBinaryCagra(provider, ii->d, config);
+        res->copyFrom(ii);
+        return res;
+    }
+#endif
+    else {
         FAISS_THROW_MSG("cannot clone this type of index");
     }
 }

data/vendor/faiss/faiss/gpu/GpuIndex.h

@@ -77,11 +77,17 @@ class GpuIndex : public faiss::Index {
     /// as needed
     /// Handles paged adds if the add set is too large; calls addInternal_
     void add(idx_t, const float* x) override;
+    void addEx(idx_t, const void* x, NumericType numeric_type) override;
 
     /// `x` and `ids` can be resident on the CPU or any GPU; copies are
     /// performed as needed
     /// Handles paged adds if the add set is too large; calls addInternal_
     void add_with_ids(idx_t n, const float* x, const idx_t* ids) override;
+    void add_with_idsEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* xids) override;
 
     /// `x` and `labels` can be resident on the CPU or any GPU; copies are
     /// performed as needed
@@ -97,6 +103,14 @@ class GpuIndex : public faiss::Index {
             float* distances,
             idx_t* labels,
             const SearchParameters* params = nullptr) const override;
+    void searchEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
 
     /// `x`, `distances` and `labels` and `recons` can be resident on the CPU or
     /// any GPU; copies are performed as needed
@@ -125,9 +139,23 @@ class GpuIndex : public faiss::Index {
    protected:
     /// Copy what we need from the CPU equivalent
     void copyFrom(const faiss::Index* index);
+    void copyFromEx(const faiss::Index* index, NumericType numeric_type) {
+        if (numeric_type == NumericType::Float32) {
+            copyFrom(index);
+        } else {
+            FAISS_THROW_MSG("GpuIndex::copyFrom: unsupported numeric type");
+        }
+    }
 
     /// Copy what we have to the CPU equivalent
     void copyTo(faiss::Index* index) const;
+    void copyToEx(faiss::Index* index, NumericType numeric_type) {
+        if (numeric_type == NumericType::Float32) {
+            copyTo(index);
+        } else {
+            FAISS_THROW_MSG("GpuIndex::copyTo: unsupported numeric type");
+        }
+    }
 
     /// Does addImpl_ require IDs? If so, and no IDs are provided, we will
     /// generate them sequentially based on the order in which the IDs are added
@@ -137,6 +165,18 @@ class GpuIndex : public faiss::Index {
     /// All data is guaranteed to be resident on our device
     virtual void addImpl_(idx_t n, const float* x, const idx_t* ids) = 0;
 
+    virtual void addImplEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* ids) {
+        if (numeric_type == NumericType::Float32) {
+            addImpl_(n, static_cast<const float*>(x), ids);
+        } else {
+            FAISS_THROW_MSG("GpuIndex::addImpl_: unsupported numeric type");
+        }
+    };
+
     /// Overridden to actually perform the search
     /// All data is guaranteed to be resident on our device
     virtual void searchImpl_(
@@ -147,13 +187,44 @@ class GpuIndex : public faiss::Index {
             idx_t* labels,
             const SearchParameters* params) const = 0;
 
+    virtual void searchImplEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            int k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params) const {
+        if (numeric_type == NumericType::Float32) {
+            searchImpl_(
+                    n,
+                    static_cast<const float*>(x),
+                    k,
+                    distances,
+                    labels,
+                    params);
+        } else {
+            FAISS_THROW_MSG("GpuIndex::searchImpl_: unsupported numeric type");
+        }
+    }
+
    private:
     /// Handles paged adds if the add set is too large, passes to
     /// addImpl_ to actually perform the add for the current page
     void addPaged_(idx_t n, const float* x, const idx_t* ids);
+    void addPagedEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* ids);
 
     /// Calls addImpl_ for a single page of GPU-resident data
     void addPage_(idx_t n, const float* x, const idx_t* ids);
+    void addPageEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* ids);
 
     /// Calls searchImpl_ for a single page of GPU-resident data
     void searchNonPaged_(
@@ -164,6 +235,15 @@ class GpuIndex : public faiss::Index {
             idx_t* outIndicesData,
             const SearchParameters* params) const;
 
+    void searchNonPagedEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            int k,
+            float* outDistancesData,
+            idx_t* outIndicesData,
+            const SearchParameters* params) const;
+
     /// Calls searchImpl_ for a single page of GPU-resident data,
     /// handling paging of the data and copies from the CPU
     void searchFromCpuPaged_(
@@ -173,6 +253,14 @@ class GpuIndex : public faiss::Index {
             float* outDistancesData,
             idx_t* outIndicesData,
             const SearchParameters* params) const;
+    void searchFromCpuPagedEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            int k,
+            float* outDistancesData,
+            idx_t* outIndicesData,
+            const SearchParameters* params) const;
 
    protected:
     /// Manages streams, cuBLAS handles and scratch memory for devices

data/vendor/faiss/faiss/gpu/GpuIndexBinaryCagra.h

@@ -0,0 +1,125 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/*
+ * Copyright (c) 2025, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <faiss/IndexBinary.h>
+#include <faiss/IndexBinaryHNSW.h>
+#include <faiss/gpu/GpuIndexCagra.h>
+
+#include <memory>
+
+namespace faiss {
+namespace gpu {
+
+class BinaryCuvsCagra;
+
+struct GpuIndexBinaryCagra : public IndexBinary {
+   public:
+    GpuIndexBinaryCagra(
+            GpuResourcesProvider* provider,
+            int dims,
+            GpuIndexCagraConfig config = GpuIndexCagraConfig());
+
+    ~GpuIndexBinaryCagra() override;
+
+    int getDevice() const;
+
+    /// Returns a reference to our GpuResources object that manages memory,
+    /// stream and handle resources on the GPU
+    std::shared_ptr<GpuResources> getResources();
+
+    /// Trains CAGRA based on the given vector data and add them along with ids.
+    /// NB: The use of the add function here is to build the CAGRA graph on
+    /// the base dataset. Use this function when you want to add vectors with
+    /// ids. Ref: https://github.com/facebookresearch/faiss/issues/4107
+    void add(idx_t n, const uint8_t* x) override;
+
+    /// Trains CAGRA based on the given vector data.
+    /// NB: The use of the train function here is to build the CAGRA graph on
+    /// the base dataset and is currently the only function to add the full set
+    /// of vectors (without IDs) to the index. There is no external quantizer to
+    /// be trained here.
+    void train(idx_t n, const uint8_t* x) override;
+
+    /// Initialize ourselves from the given CPU index; will overwrite
+    /// all data in ourselves
+    void copyFrom(const faiss::IndexBinaryHNSWCagra* index);
+
+    /// Copy ourselves to the given CPU index; will overwrite all data
+    /// in the index instance
+    void copyTo(faiss::IndexBinaryHNSWCagra* index) const;
+
+    void reset() override;
+
+    std::vector<idx_t> get_knngraph() const;
+
+    void search(
+            idx_t n,
+            const uint8_t* x,
+            // faiss::IndexBinary has idx_t for k
+            idx_t k,
+            int* distances,
+            faiss::idx_t* labels,
+            const faiss::SearchParameters* params = nullptr) const override;
+
+   protected:
+    /// Called from search when the input data is on the CPU;
+    /// potentially allows for pinned memory usage
+    void searchFromCpuPaged_(
+            idx_t n,
+            const uint8_t* x,
+            int k,
+            int* outDistancesData,
+            idx_t* outIndicesData,
+            const SearchParameters* search_params) const;
+
+    void searchNonPaged_(
+            idx_t n,
+            const uint8_t* x,
+            int k,
+            int* outDistancesData,
+            idx_t* outIndicesData,
+            const SearchParameters* search_params) const;
+
+    void searchImpl_(
+            idx_t n,
+            const uint8_t* x,
+            int k,
+            int* distances,
+            idx_t* labels,
+            const SearchParameters* search_params) const;
+
+   protected:
+    /// Manages streans, cuBLAS handles and scratch memory for devices
+    std::shared_ptr<GpuResources> resources_;
+
+    /// Configuration options
+    const GpuIndexCagraConfig cagraConfig_;
+
+    /// Instance that we own; contains the cuVS index
+    std::shared_ptr<BinaryCuvsCagra> index_;
+};
+
+} // namespace gpu
+} // namespace faiss

data/vendor/faiss/faiss/gpu/GpuIndexCagra.h

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 /*
- * Copyright (c) 2024, NVIDIA CORPORATION.
+ * Copyright (c) 2024-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,9 @@
 #include <faiss/gpu/GpuIndex.h>
 #include <faiss/gpu/GpuIndexIVFPQ.h>
 
+#include <variant>
+#include "faiss/Index.h"
+
 namespace faiss {
 struct IndexHNSWCagra;
 }
@@ -34,13 +37,16 @@ struct IndexHNSWCagra;
 namespace faiss {
 namespace gpu {
 
+template <typename data_t>
 class CuvsCagra;
 
 enum class graph_build_algo {
     /// Use IVF-PQ to build all-neighbors knn graph
     IVF_PQ,
     /// Use NN-Descent to build all-neighbors knn graph
-    NN_DESCENT
+    NN_DESCENT,
+    /// Use iterative search to build knn graph
+    ITERATIVE_SEARCH
 };
 
 /// A type for specifying how PQ codebooks are created.
@@ -116,7 +122,6 @@ struct IVFPQBuildCagraConfig {
     /// the algorithm always allocates the minimum amount of memory required to
     /// store the given number of records. Set this flag to `true` if you prefer
     /// to use as little GPU memory for the database as possible.
-
     bool conservative_memory_allocation = false;
 };
 
@@ -177,6 +182,9 @@ struct GpuIndexCagraConfig : public GpuIndexConfig {
     std::shared_ptr<IVFPQSearchCagraConfig> ivf_pq_search_params{nullptr};
     float refine_rate = 2.0f;
     bool store_dataset = true;
+
+    /// Whether to use MST optimization to guarantee graph connectivity.
+    bool guarantee_connectivity = false;
 };
 
 enum class search_algo {
@@ -250,6 +258,7 @@ struct GpuIndexCagra : public GpuIndex {
     /// the base dataset. Use this function when you want to add vectors with
     /// ids. Ref: https://github.com/facebookresearch/faiss/issues/4107
     void add(idx_t n, const float* x) override;
+    void addEx(idx_t n, const void* x, NumericType numeric_type) override;
 
     /// Trains CAGRA based on the given vector data.
     /// NB: The use of the train function here is to build the CAGRA graph on
@@ -257,10 +266,14 @@ struct GpuIndexCagra : public GpuIndex {
     /// of vectors (without IDs) to the index. There is no external quantizer to
     /// be trained here.
     void train(idx_t n, const float* x) override;
+    void trainEx(idx_t n, const void* x, NumericType numeric_type) override;
 
     /// Initialize ourselves from the given CPU index; will overwrite
     /// all data in ourselves
     void copyFrom(const faiss::IndexHNSWCagra* index);
+    void copyFromEx(
+            const faiss::IndexHNSWCagra* index,
+            NumericType numeric_type);
 
     /// Copy ourselves to the given CPU index; will overwrite all data
     /// in the index instance
@@ -270,10 +283,17 @@ struct GpuIndexCagra : public GpuIndex {
 
     std::vector<idx_t> get_knngraph() const;
 
+    faiss::NumericType get_numeric_type() const;
+
    protected:
     bool addImplRequiresIDs_() const override;
 
     void addImpl_(idx_t n, const float* x, const idx_t* ids) override;
+    void addImplEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* ids) override;
 
     /// Called from GpuIndex for search
     void searchImpl_(
@@ -283,12 +303,27 @@ struct GpuIndexCagra : public GpuIndex {
             float* distances,
             idx_t* labels,
             const SearchParameters* search_params) const override;
+    void searchImplEx_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            int k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* search_params) const override;
 
     /// Our configuration options
     const GpuIndexCagraConfig cagraConfig_;
 
+    faiss::NumericType numeric_type_;
+
     /// Instance that we own; contains the inverted lists
-    std::shared_ptr<CuvsCagra> index_;
+    std::variant<
+            std::monostate,
+            std::shared_ptr<CuvsCagra<float>>,
+            std::shared_ptr<CuvsCagra<half>>,
+            std::shared_ptr<CuvsCagra<int8_t>>>
+            index_;
 };
 
 } // namespace gpu

data/vendor/faiss/faiss/gpu/impl/IndexUtils.h

@@ -17,13 +17,13 @@ namespace gpu {
 /// Returns the maximum k-selection value supported based on the CUDA SDK that
 /// we were compiled with. .cu files can use DeviceDefs.cuh, but this is for
 /// non-CUDA files
-int getMaxKSelection();
+int getMaxKSelection(bool use_cuvs = false);
 
 // Validate the k parameter for search
-void validateKSelect(int k);
+void validateKSelect(int k, bool use_cuvs = false);
 
 // Validate the nprobe parameter for search
-void validateNProbe(size_t nprobe);
+void validateNProbe(size_t nprobe, bool use_cuvs = false);
 
 } // namespace gpu
 } // namespace faiss

data/vendor/faiss/faiss/gpu/test/TestGpuIndexBinaryFlat.cpp

@@ -79,7 +79,7 @@ void testGpuIndexBinaryFlat(int kOverride = -1) {
 
     int k = kOverride > 0
             ? kOverride
-            : faiss::gpu::randVal(1, faiss::gpu::getMaxKSelection());
+            : faiss::gpu::randVal(1, faiss::gpu::getMaxKSelection(false));
     int numVecs = faiss::gpu::randVal(k + 1, 20000);
     int numQuery = faiss::gpu::randVal(1, 1000);
 

data/vendor/faiss/faiss/gpu/test/TestGpuIndexFlat.cpp

@@ -56,7 +56,8 @@ void testFlat(const TestFlatOptions& opt) {
     int k = opt.useFloat16
             ? std::min(faiss::gpu::randVal(1, 50), numVecs)
             : std::min(
-                      faiss::gpu::randVal(1, faiss::gpu::getMaxKSelection()),
+                      faiss::gpu::randVal(
+                              1, faiss::gpu::getMaxKSelection(opt.use_cuvs)),
                       numVecs);
     if (opt.kOverride > 0) {
         k = opt.kOverride;
@@ -164,7 +165,7 @@ TEST(TestGpuIndexFlat, L2_Float32) {
 
 // At least one test for the k > 1024 select
 TEST(TestGpuIndexFlat, L2_k_2048) {
-    if (faiss::gpu::getMaxKSelection() >= 2048) {
+    if (faiss::gpu::getMaxKSelection(false) >= 2048) {
         TestFlatOptions opt;
         opt.metric = faiss::MetricType::METRIC_L2;
         opt.useFloat16 = false;

data/vendor/faiss/faiss/gpu/utils/CuvsFilterConvert.h

@@ -0,0 +1,41 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/*
+ * Copyright (c) 2025, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cuvs/core/bitset.hpp>
+#include <faiss/gpu/GpuResources.h>
+#include <faiss/impl/IDSelector.h>
+
+#pragma GCC visibility push(default)
+namespace faiss::gpu {
+/// Convert a Faiss IDSelector to a cuvs::core::bitset_view
+/// @param res The GpuResources object to use for the conversion
+/// @param selector The Faiss IDSelector to convert
+/// @param bitset The cuvs::core::bitset_view to store the result
+/// @param num_threads Number of threads to use for the conversion. If 0, the
+/// number of threads is set to the number of available threads.
+void convert_to_bitset(
+        faiss::gpu::GpuResources* res,
+        const faiss::IDSelector& selector,
+        cuvs::core::bitset_view<uint32_t, uint32_t> bitset,
+        int num_threads = 0);
+} // namespace faiss::gpu

data/vendor/faiss/faiss/impl/AuxIndexStructures.cpp

@@ -168,23 +168,26 @@ void RangeSearchPartialResult::merge(
         std::vector<RangeSearchPartialResult*>& partial_results,
         bool do_delete) {
     int npres = partial_results.size();
-    if (npres == 0)
+    if (npres == 0) {
         return;
+    }
     RangeSearchResult* result = partial_results[0]->res;
     size_t nx = result->nq;
 
     // count
     for (const RangeSearchPartialResult* pres : partial_results) {
-        if (!pres)
+        if (!pres) {
             continue;
+        }
         for (const RangeQueryResult& qres : pres->queries) {
             result->lims[qres.qno] += qres.nres;
         }
     }
     result->do_allocation();
     for (int j = 0; j < npres; j++) {
-        if (!partial_results[j])
+        if (!partial_results[j]) {
             continue;
+        }
         partial_results[j]->copy_result(true);
         if (do_delete) {
             delete partial_results[j];