Cleanup and clang-format [skip ci]

Author: lums658

src/include/detail/ivf/qv.h

@@ -41,12 +41,11 @@
 #include "flat_query.h"
 #include "linalg.h"
 
-
 namespace detail::ivf {
 
 /**
- * Overload for already opened arrays.  Since the array is already opened, we don't need
- * to specify its type with a template parameter.
+ * Overload for already opened arrays.  Since the array is already opened, we
+ * don't need to specify its type with a template parameter.
  */
 auto qv_query_heap_infinite_ram(
     auto&& shuffled_db,
@@ -77,7 +76,6 @@ auto qv_query_heap_infinite_ram(
     bool nth,
     size_t nthreads);
 
-
 /**
  * @brief Query a (small) set of query vectors against a vector database.
  * This version loads the entire partition array into memory and then
@@ -99,7 +97,6 @@ auto qv_query_heap_infinite_ram(
     size_t nthreads) {
   scoped_timer _{tdb_func__};
 
-
   // Read the shuffled database and ids
   // @todo To this more systematically
   auto shuffled_db = tdbColMajorMatrix<T>(ctx, part_uri);
@@ -117,7 +114,6 @@ auto qv_query_heap_infinite_ram(
       nthreads);
 }
 
-
 auto qv_query_heap_infinite_ram(
     const std::string& part_uri,
     auto&& centroids,
@@ -233,8 +229,10 @@ auto qv_query_heap_finite_ram(
     size_t nthreads) {
   scoped_timer _{tdb_func__};
 
-  using parts_type = typename std::remove_reference_t<decltype(centroids)>::value_type;
-  using indices_type = typename std::remove_reference_t<decltype(indices)>::value_type;
+  using parts_type =
+      typename std::remove_reference_t<decltype(centroids)>::value_type;
+  using indices_type =
+      typename std::remove_reference_t<decltype(indices)>::value_type;
 
   size_t num_queries = size(q);
 
@@ -287,7 +285,11 @@ auto qv_query_heap_finite_ram(
                          indices[active_partitions[i]];
   }
 
-  auto shuffled_db = tdbColMajorPartitionedMatrix<T, shuffled_ids_type, indices_type, parts_type>(
+  auto shuffled_db = tdbColMajorPartitionedMatrix<
+      T,
+      shuffled_ids_type,
+      indices_type,
+      parts_type>(
       ctx,
       part_uri,
       std::move(indices),
@@ -300,10 +302,13 @@ auto qv_query_heap_finite_ram(
   for (size_t i = 0; i < size(new_indices) - 1; ++i) {
     auto partition_size = new_indices[i + 1] - new_indices[i];
     max_partition_size = std::max<size_t>(max_partition_size, partition_size);
-    _memory_data.insert_entry(tdb_func__ + " (predicted)", partition_size * sizeof(T) * shuffled_db.num_rows());
+    _memory_data.insert_entry(
+        tdb_func__ + " (predicted)",
+        partition_size * sizeof(T) * shuffled_db.num_rows());
   }
-    _memory_data.insert_entry(tdb_func__ + " (upper bound)", nprobe * num_queries * sizeof(T) * max_partition_size);
-
+  _memory_data.insert_entry(
+      tdb_func__ + " (upper bound)",
+      nprobe * num_queries * sizeof(T) * max_partition_size);
 
   assert(shuffled_db.num_cols() == size(shuffled_db.ids()));
 

src/include/detail/linalg/matrix.h

@@ -272,9 +272,7 @@ std::string matrix_info(const Matrix& A, const std::string& msg = "") {
   return str;
 }
 
-
-
- /**********************************************************************
+/**********************************************************************
  *
  * Some debugging utilities.
  *

src/include/detail/linalg/tdb_io.h

@@ -34,8 +34,8 @@
 
 #include <tiledb/tiledb>
 #include "detail/linalg/matrix.h"
-#include "utils/timer.h"
 #include "utils/logging.h"
+#include "utils/timer.h"
 
 /**
  * Write the contents of a Matrix to a TileDB array.

src/include/detail/linalg/tdb_matrix.h

@@ -69,7 +69,6 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
   constexpr static auto matrix_order_{order_v<LayoutPolicy>};
 
  private:
-
   log_timer constructor_timer{"tdbMatrix constructor"};
 
   std::reference_wrapper<const tiledb::Context> ctx_;
@@ -101,10 +100,8 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
   tdbMatrix(
       const tiledb::Context& ctx,
       const std::string& uri,
-      size_t num_elts) noexcept requires(std::
-                                             is_same_v<
-                                                 LayoutPolicy,
-                                                 stdx::layout_right>)
+      size_t num_elts) noexcept
+      requires(std::is_same_v<LayoutPolicy, stdx::layout_right>)
       : tdbMatrix(ctx, uri, num_elts, 0) {
   }
 
@@ -120,10 +117,8 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
   tdbMatrix(
       const tiledb::Context& ctx,
       const std::string& uri,
-      size_t num_elts) noexcept requires(std::
-                                             is_same_v<
-                                                 LayoutPolicy,
-                                                 stdx::layout_left>)
+      size_t num_elts) noexcept
+      requires(std::is_same_v<LayoutPolicy, stdx::layout_left>)
       : tdbMatrix(ctx, uri, 0, num_elts) {
   }
 
@@ -206,7 +201,6 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
       : ctx_{ctx}
       , array_{ctx, uri, TILEDB_READ}
       , schema_{array_.schema()} {
-
     constructor_timer.stop();
     scoped_timer _{tdb_func__ + uri};
 
@@ -273,10 +267,11 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
     }
 
     // Create a subarray that reads the array up to the specified subset.
-    std::vector<int32_t> subarray_vals = {(int32_t)row_begin,
-                                          (int32_t)row_end - 1,
-                                          (int32_t)col_begin,
-                                          (int32_t)col_end - 1};
+    std::vector<int32_t> subarray_vals = {
+        (int32_t)row_begin,
+        (int32_t)row_end - 1,
+        (int32_t)col_begin,
+        (int32_t)col_end - 1};
     tiledb::Subarray subarray(ctx_, array_);
     subarray.set_subarray(subarray_vals);
 
@@ -290,7 +285,6 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
     query.submit();
     _memory_data.insert_entry(tdb_func__, num_rows * num_cols * sizeof(T));
 
-
     // assert(tiledb::Query::Status::COMPLETE == query.query_status());
     if (tiledb::Query::Status::COMPLETE != query.query_status()) {
       throw std::runtime_error("Query status is not complete -- fix me");
@@ -385,10 +379,11 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
         size_t num_elements = len * dimension;
 
         // Create a subarray that reads the array up to the specified subset.
-        std::vector<int32_t> subarray_vals = {(int32_t)0,
-                                              (int32_t)dimension - 1,
-                                              (int32_t)start,
-                                              (int32_t)stop - 1};
+        std::vector<int32_t> subarray_vals = {
+            (int32_t)0,
+            (int32_t)dimension - 1,
+            (int32_t)start,
+            (int32_t)stop - 1};
         tiledb::Subarray subarray(ctx_, array_);
         subarray.set_subarray(subarray_vals);
 
@@ -403,7 +398,6 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
         query.submit();
         _memory_data.insert_entry(tdb_func__, num_elements * sizeof(T));
 
-
         // assert(tiledb::Query::Status::COMPLETE == query.query_status());
         if (tiledb::Query::Status::COMPLETE != query.query_status()) {
           throw std::runtime_error("Query status is not complete -- fix me");
@@ -446,8 +440,8 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
         size_t num_elements = len;
 
         // Create a subarray that reads the array up to the specified subset.
-        std::vector<int32_t> subarray_vals = {(int32_t)start,
-                                              (int32_t)stop - 1};
+        std::vector<int32_t> subarray_vals = {
+            (int32_t)start, (int32_t)stop - 1};
         tiledb::Subarray subarray(ctx_, ids_array_);
         subarray.set_subarray(subarray_vals);
 
@@ -458,7 +452,6 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
         query.submit();
         _memory_data.insert_entry(tdb_func__, num_elements * sizeof(T));
 
-
         if (tiledb::Query::Status::COMPLETE != query.query_status()) {
           throw std::runtime_error("Query status is not complete -- fix me");
         }
@@ -538,10 +531,11 @@ class tdbMatrix : public Matrix<T, LayoutPolicy, I> {
     }
 
     // Create a subarray that reads the array with the specified view
-    std::vector<int32_t> subarray_vals = {(int32_t)std::get<0>(row_view_),
-                                          (int32_t)std::get<1>(row_view_) - 1,
-                                          (int32_t)std::get<0>(col_view_),
-                                          (int32_t)std::get<1>(col_view_) - 1};
+    std::vector<int32_t> subarray_vals = {
+        (int32_t)std::get<0>(row_view_),
+        (int32_t)std::get<1>(row_view_) - 1,
+        (int32_t)std::get<0>(col_view_),
+        (int32_t)std::get<1>(col_view_) - 1};
     tiledb::Subarray subarray(ctx_, array_);
     subarray.set_subarray(subarray_vals);
 

src/include/detail/linalg/tdb_partitioned_matrix.h

@@ -279,7 +279,7 @@ class tdbPartitionedMatrix : public Matrix<T, LayoutPolicy, I> {
        */
       std::get<0>(col_view_) = std::get<1>(col_view_);  // # columns
       std::get<0>(col_part_view_) =
-          std::get<1>(col_part_view_);                  // # partitions
+          std::get<1>(col_part_view_);  // # partitions
 
       std::get<1>(col_part_view_) = std::get<0>(col_part_view_);
       for (size_t i = std::get<0>(col_part_view_); i < total_num_parts_; ++i) {
@@ -437,8 +437,13 @@ template <
     class indices_type,
     class parts_type,
     class I = size_t>
-using tdbRowMajorPartitionedMatrix =
-    tdbPartitionedMatrix<T, shuffled_ids_type, indices_type, parts_type, stdx::layout_right, I>;
+using tdbRowMajorPartitionedMatrix = tdbPartitionedMatrix<
+    T,
+    shuffled_ids_type,
+    indices_type,
+    parts_type,
+    stdx::layout_right,
+    I>;
 
 /**
  * Convenience class for column-major matrices.
@@ -449,7 +454,12 @@ template <
     class indices_type,
     class parts_type,
     class I = size_t>
-using tdbColMajorPartitionedMatrix =
-    tdbPartitionedMatrix<T, shuffled_ids_type, indices_type, parts_type, stdx::layout_left, I>;
+using tdbColMajorPartitionedMatrix = tdbPartitionedMatrix<
+    T,
+    shuffled_ids_type,
+    indices_type,
+    parts_type,
+    stdx::layout_left,
+    I>;
 
 #endif  // TILEDB_PARTITIONED_MATRIX_H

src/include/fixed_min_queues.h

@@ -27,8 +27,9 @@
  *
  * @section DESCRIPTION
  *
- * Contains two implementations of a fixed-size min-heap (to experiment with potential performance differences).
- * Also contains an implementation of a fixed_size min-heap for pairs.
+ * Contains two implementations of a fixed-size min-heap (to experiment with
+ * potential performance differences). Also contains an implementation of a
+ * fixed_size min-heap for pairs.
  *
  * This type of heap is used to maintain the top k small scores as we compute
  * scores during similarity search.
@@ -149,7 +150,8 @@ class fixed_min_pair_heap : public std::vector<std::tuple<T, U>> {
 template <class T>
 using fixed_min_heap = fixed_min_set_heap_1<T>;
 
-#ifdef ALLHEAPS  // Kept here for historical comparison reasons.  They are really slow.
+#ifdef ALLHEAPS  // Kept here for historical comparison reasons.  They are
+                 // really slow.
 template <class T, class Compare = std::less<T>>
 class fixed_min_set_heap_3 : public std::vector<T> {
   using Base = std::vector<T>;

src/include/ivf_index.h

@@ -53,13 +53,12 @@
 #include <thread>
 
 #include "algorithm.h"
-#include "array_types.h"
 #include "defs.h"
 #include "linalg.h"
 
 #include "detail/flat/qv.h"
 
-template <class T = shuffled_db_type>
+template <class T, class shuffled_ids_type, class indices_type>
 class kmeans_index {
   // Random device to seed the random number generator
   std::random_device rd;
@@ -73,7 +72,7 @@ class kmeans_index {
 
   ColMajorMatrix<T> centroids_;
   std::vector<indices_type> indices_;
-  std::vector<indices_type> shuffled_ids_;
+  std::vector<shuffled_ids_type> shuffled_ids_;
   ColMajorMatrix<T> shuffled_db_;
 
  public:
@@ -258,7 +257,6 @@ class kmeans_index {
 
       // @todo parallelize
 
-
       for (size_t j = 0; j < nlist_; ++j) {
         auto centroid = centroids_[j];
         for (size_t k = 0; k < dimension_; ++k) {
@@ -271,32 +269,32 @@ class kmeans_index {
 
     // Debugging
 #ifdef _SAVE_PARTITIONS
-      {
-        char tempFileName[L_tmpnam];
-        tmpnam(tempFileName);
-
-        std::ofstream file(tempFileName);
-        if (!file) {
-          std::cout << "Error opening the file." << std::endl;
-          return;
-        }
+    {
+      char tempFileName[L_tmpnam];
+      tmpnam(tempFileName);
+
+      std::ofstream file(tempFileName);
+      if (!file) {
+        std::cout << "Error opening the file." << std::endl;
+        return;
+      }
 
-        for (const auto& element : degrees) {
-          file << element << ',';
-        }
-        file << std::endl;
+      for (const auto& element : degrees) {
+        file << element << ',';
+      }
+      file << std::endl;
 
-        file.close();
+      file.close();
 
-        std::cout << "Data written to file: " << tempFileName << std::endl;
-      }
-#endif
+      std::cout << "Data written to file: " << tempFileName << std::endl;
     }
+#endif
+  }
 
-    void train(const ColMajorMatrix<T>& training_set) {
-      kmeans_pp(training_set);
-      train_no_init(training_set);
-    }
+  void train(const ColMajorMatrix<T>& training_set) {
+    kmeans_pp(training_set);
+    train_no_init(training_set);
+  }
 
 #if 0
   // @todo WIP
@@ -338,9 +336,9 @@ class kmeans_index {
   }
 #endif
 
-    auto& get_centroids() {
-      return centroids_;
-    }
-  };
+  auto& get_centroids() {
+    return centroids_;
+  }
+};
 
-#endif  // TILEDB_IVF_INDEX_H
+#endif  // TILEDB_IVF_INDEX_H

src/include/ivf_query.h

@@ -34,7 +34,6 @@
 #ifndef TDB_IVF_QUERY_H
 #define TDB_IVF_QUERY_H
 
-
 #include "detail/ivf/gemm.h"
 #include "detail/ivf/qv.h"
 #include "detail/ivf/vq.h"