Replace asserts with exceptions in C++ code (#410)

Author: jparismorgan

src/include/api/feature_vector_array.h

@@ -361,7 +361,11 @@ const FeatureVectorArray::tdb_col_major_matrix_with_ids_table_type FeatureVector
 using QueryVectorArray = FeatureVectorArray;
 
 bool validate_top_k(const FeatureVectorArray& a, const FeatureVectorArray& b) {
-  // assert(a.datatype() == b.datatype());
+  if (a.feature_type() != b.feature_type()) {
+    throw std::runtime_error(
+        "[feature_vector_array@validate_top_k] Feature types do not match: " +
+        a.feature_type_string() + " vs " + b.feature_type_string());
+  }
 
   auto proc_b = [&b](auto& aview) {
     switch (b.feature_type()) {

src/include/detail/graph/best_first.h

@@ -121,7 +121,9 @@ auto best_first_O1(
     auto&& [_, p_star] = frontier.back();
     frontier.pop_back();
 
-    assert(!(visited.count(p_star) > 0));
+    if (visited.count(p_star) > 0) {
+      throw std::runtime_error("[best_first@best_first_O1] Vertex was visited");
+    }
     visited.insert(p_star);
 
     for (auto&& [_, neighbor_id] : graph[p_star]) {
@@ -176,10 +178,13 @@ auto best_first_O2(
   enfrontiered.insert(source);
 
   while (!frontier.empty()) {
-    assert(is_minmax_heap(
-        frontier.begin(), frontier.end(), [](auto&& a, auto&& b) {
-          return std::get<0>(a) < std::get<0>(b);
-        }));
+    if (!is_minmax_heap(
+            frontier.begin(), frontier.end(), [](auto&& a, auto&& b) {
+              return std::get<0>(a) < std::get<0>(b);
+            })) {
+      throw std::runtime_error(
+          "[best_first@best_first_O2] Frontier is not a min-max heap");
+    }
 
 #if 0
     std::cout << "\n\n{\n";
@@ -211,7 +216,9 @@ auto best_first_O2(
     frontier.pop_back();
     enfrontiered.erase(p_star);
 
-    assert(p_star == q_star);
+    if (p_star != q_star) {
+      throw std::runtime_error("[best_first@best_first_O2] p_star != q_star");
+    }
 
     visited.insert(p_star);
 
@@ -384,7 +391,11 @@ auto best_first_O3(
   pq.insert(heuristic, source);
   auto&& [source_iter, success] =
       vertex_state_map.emplace(std::make_pair(source, 0));
-  assert(success);
+  if (!success) {
+    throw std::runtime_error(
+        "[best_first@best_first_O3] Could not insert source into "
+        "vertex_state_map");
+  }
 
   set_enpqd(source_iter->second);
 
@@ -396,10 +407,13 @@ auto best_first_O3(
   set_enpqd(source_iter->second);
 
   while (!frontier.empty()) {
-    assert(is_minmax_heap(
-        frontier.begin(), frontier.end(), [](auto&& a, auto&& b) {
-          return std::get<0>(a) < std::get<0>(b);
-        }));
+    if (!is_minmax_heap(
+            frontier.begin(), frontier.end(), [](auto&& a, auto&& b) {
+              return std::get<0>(a) < std::get<0>(b);
+            })) {
+      throw std::runtime_error(
+          "[best_first@best_first_O3] Frontier is not a min-max heap");
+    }
 
 #if 0
     std::cout << "\n\n{\n";
@@ -414,9 +428,11 @@ auto best_first_O3(
 
     auto debug_p_star = p_star;
 
-    // assert(vertex_state_map.find(p_star) == vertex_state_map.end());
     auto p_star_iter = vertex_state_map.find(p_star);
-    assert(p_star_iter != vertex_state_map.end());
+    if (p_star_iter == vertex_state_map.end()) {
+      throw std::runtime_error(
+          "[best_first@best_first_O3] p_star_iter == vertex_state_map.end()");
+    }
 
     pop_minmax_heap_min(
         frontier.begin(), frontier.end(), [](auto&& a, auto&& b) {
@@ -443,7 +459,9 @@ auto best_first_O3(
     clear_enfrontiered(p_star_iter->second);
     set_visited(p_star_iter->second);
 
-    assert(p_star == q_star);
+    if (p_star != q_star) {
+      throw std::runtime_error("[best_first@best_first_O3] p_star != q_star");
+    }
 
     score_type min_evicted_score = std::numeric_limits<score_type>::max();
     auto evicted_pq = std::vector<node_type>{};
@@ -454,7 +472,11 @@ auto best_first_O3(
       if (neighbor_state_iter == vertex_state_map.end()) {
         auto [local_neighbor_state_iter, success] =
             vertex_state_map.emplace(neighbor_id, 0);
-        assert(success);
+        if (!success) {
+          throw std::runtime_error(
+              "[best_first@best_first_O3] Could not insert neighbor_id into "
+              "vertex_state_map");
+        }
         neighbor_state_iter = local_neighbor_state_iter;
       } else {
         if (!is_unvisited(neighbor_state_iter->second)) {
@@ -472,7 +494,11 @@ auto best_first_O3(
         set_enpqd(neighbor_state_iter->second);
         if (evicted) {
           auto evicted_state_iter = vertex_state_map.find(evicted_id);
-          assert(evicted_state_iter != vertex_state_map.end());
+          if (evicted_state_iter == vertex_state_map.end()) {
+            throw std::runtime_error(
+                "[best_first@best_first_O3] evicted_state_iter == "
+                "vertex_state_map.end()");
+          }
 
           if (is_visited(evicted_state_iter->second)) {
             // Only mark as evicted if not visited
@@ -498,7 +524,12 @@ auto best_first_O3(
       return std::get<0>(a) < std::get<0>(b);
     });
 
-    assert(size(frontier) <= size(pq));
+    if (size(frontier) > size(pq)) {
+      throw std::runtime_error(
+          "[best_first@best_first_O3] size(frontier) (" +
+          std::to_string(size(frontier)) + ") > size(pq) (" +
+          std::to_string(size(pq)) + ")");
+    }
     // vertex_state_map.erase(p_star);
   }
   auto top_k = std::vector<id_type>(k_nn);
@@ -585,18 +616,33 @@ auto best_first_O4(
     }
     clear_enfrontiered(vertex_state_property_map[p_star]);
     //    std::cout << "p_star " << p_star << std::endl;
-    assert(is_visited(vertex_state_property_map[p_star]));
-    assert(!is_evicted(vertex_state_property_map[p_star]));
-    assert(!is_enfrontiered(vertex_state_property_map[p_star]));
+    if (!is_visited(vertex_state_property_map[p_star])) {
+      throw std::runtime_error(
+          "[best_first@best_first_O4] p_star is not visited");
+    }
+    if (is_evicted(vertex_state_property_map[p_star])) {
+      throw std::runtime_error("[best_first@best_first_O4] p_star is evicted");
+    }
+    if (is_enfrontiered(vertex_state_property_map[p_star])) {
+      throw std::runtime_error(
+          "[best_first@best_first_O4] p_star is enfrontiered");
+    }
 
     p_star = std::numeric_limits<id_type>::max();
     auto p_min_score = std::numeric_limits<score_type>::max();
 
     for (auto&& [pq_score, pq_id] : pq) {
       if (pq_score < p_min_score) {
         auto pq_state = vertex_state_property_map[pq_id];
-        assert(!is_evicted(pq_state));
-        assert(is_enpqd(pq_state));
+
+        if (is_evicted(pq_state)) {
+          throw std::runtime_error(
+              "[best_first@best_first_O4] pq_state is evicted");
+        }
+        if (!is_enpqd(pq_state)) {
+          throw std::runtime_error(
+              "[best_first@best_first_O4] pq_state is not enpqd");
+        }
         if (!is_visited(pq_state)) {
           p_star = pq_id;
           p_min_score = pq_score;
@@ -646,7 +692,11 @@ auto best_first_O5(
   pq.insert(heuristic, source);
   auto&& [source_iter, success] =
       vertex_state_map.emplace(std::make_pair(source, 0));
-  assert(success);
+  if (!success) {
+    throw std::runtime_error(
+        "[best_first@best_first_O3] Could not insert source into "
+        "vertex_state_map");
+  }
 
   set_enpqd(source_iter->second);
 
@@ -656,7 +706,10 @@ auto best_first_O5(
     visited.insert(p_star);
 
     auto p_star_iter = vertex_state_map.find(p_star);
-    assert(p_star_iter != vertex_state_map.end());
+    if (p_star_iter == vertex_state_map.end()) {
+      throw std::runtime_error(
+          "[best_first@best_first_O3] p_star_iter == vertex_state_map.end()");
+    }
     clear_enfrontiered(p_star_iter->second);
     set_visited(p_star_iter->second);
 
@@ -666,7 +719,11 @@ auto best_first_O5(
       if (neighbor_state_iter == vertex_state_map.end()) {
         auto [local_neighbor_state_iter, success] =
             vertex_state_map.emplace(neighbor_id, 0);
-        assert(success);
+        if (!success) {
+          throw std::runtime_error(
+              "[best_first@best_first_O3] Could not insert neighbor_id into "
+              "vertex_state_map");
+        }
         neighbor_state_iter = local_neighbor_state_iter;
       } else {
         if (!is_unvisited(neighbor_state_iter->second)) {
@@ -684,7 +741,11 @@ auto best_first_O5(
         set_enpqd(neighbor_state_iter->second);
         if (evicted) {
           auto evicted_state_iter = vertex_state_map.find(evicted_id);
-          assert(evicted_state_iter != vertex_state_map.end());
+          if (evicted_state_iter == vertex_state_map.end()) {
+            throw std::runtime_error(
+                "[best_first@best_first_O3] evicted_state_iter == "
+                "vertex_state_map.end()");
+          }
           set_evicted(evicted_state_iter->second);
         }
       } else {
@@ -697,8 +758,16 @@ auto best_first_O5(
 
     for (auto&& [pq_score, pq_id] : pq) {
       auto pq_state_iter = vertex_state_map.find(pq_id);
-      assert(!is_evicted(pq_state_iter->second));
-      assert(is_enpqd(pq_state_iter->second));
+
+      if (is_evicted(pq_state_iter->second)) {
+        throw std::runtime_error(
+            "[best_first@best_first_O3] pq_state_iter is evicted");
+      }
+      if (!is_enpqd(pq_state_iter->second)) {
+        throw std::runtime_error(
+            "[best_first@best_first_O3] pq_state_iter is not enpqd");
+      }
+
       if (!is_visited(pq_state_iter->second)) {
         if (pq_score < p_min_score) {
           p_star = pq_id;

src/include/detail/graph/diskann.h

@@ -152,13 +152,19 @@ auto read_diskann_mem_index_with_scores(
     for (size_t i = 0; i < num_neighbors; ++i) {
       uint32_t id;
       binary_file.read((char*)&id, 4);
-      assert(id < num_nodes);
+      if (id >= num_nodes) {
+        throw std::runtime_error(
+            "[read_diskann_mem_index_with_scores] id >= num_nodes");
+      }
       g.add_edge(node, id, l2_distance(x[node], x[id]));
     }
     ++node;
   }
   binary_file.close();
-  assert(node == num_nodes);
+  if (node != num_nodes) {
+    throw std::runtime_error(
+        "[read_diskann_mem_index_with_scores] node != num_nodes");
+  }
 
   return g;
 }

src/include/detail/graph/greedy_search.h

@@ -299,7 +299,11 @@ auto greedy_search_O1(
 
   static_assert(std::integral<id_type>);
 
-  assert(L >= k_nn);
+  if (L < k_nn) {
+    throw std::runtime_error(
+        "[greedy_search_O1] L (" + std::to_string(L) + ") < k_nn (" +
+        std::to_string(k_nn) + ")");
+  }
 
   std::unordered_set<id_type> visited_vertices;
   auto visited = [&visited_vertices](auto&& v) {
@@ -550,7 +554,10 @@ auto robust_prune(
           return std::get<0>(a) < std::get<0>(b);
         }));
 
-    assert(p_star != p);
+    if (p_star == p) {
+      throw std::runtime_error("[robust_prune] p_star == p");
+    }
+
     if (noisy_robust_prune) {
       std::cout << "::::" << p_star << std::endl;
       debug_min_heap(V, "V: ", 1);

src/include/detail/ivf/dist_qv.h

@@ -123,7 +123,11 @@ auto dist_qv_finite_ram_part(
           num_queries,
           fixed_min_pair_heap<score_type, shuffled_ids_type>(k_nn));
 
-  assert(::num_partitions(partitioned_vectors) == size(dist_active_partitions));
+  if (::num_partitions(partitioned_vectors) != size(dist_active_partitions)) {
+    throw std::runtime_error(
+        "[dist_qv_finite_ram_part] num_partitions(partitioned_vectors) != "
+        "size(dist_active_partitions)");
+  }
 
   auto current_part_size = ::num_partitions(partitioned_vectors);
   size_t parts_per_thread = (current_part_size + nthreads - 1) / nthreads;
@@ -267,7 +271,12 @@ auto dist_qv_finite_ram(
   scoped_timer _{tdb_func__ + " " + part_uri};
 
   // Check that the size of the indices vector is correct
-  assert(size(indices) == centroids.num_cols() + 1);
+  if (size(indices) != centroids.num_cols() + 1) {
+    throw std::runtime_error(
+        "[dist_qv_finite_ram] size(indices) (" + std::to_string(size(indices)) +
+        ") != centroids.num_cols() + 1 (" +
+        std::to_string(centroids.num_cols() + 1) + ")");
+  }
 
   using score_type = float;
   using indices_type =

src/include/detail/ivf/index.h

@@ -155,7 +155,10 @@ int ivf_index(
 
         shuffled_ids[ibin] = external_ids[i];
 
-        assert(ibin < shuffled_db.num_cols());
+        if (ibin >= shuffled_db.num_cols()) {
+          throw std::runtime_error(
+              "[ivf_index] ibin >= shuffled_db.num_cols()");
+        }
         for (size_t j = 0; j < db.num_rows(); ++j) {
           shuffled_db(j, ibin) = db(j, i);
         }
@@ -170,7 +173,10 @@ int ivf_index(
 
           shuffled_ids[ibin] = external_ids[i];
 
-          assert(ibin < shuffled_db.num_cols());
+          if (ibin >= shuffled_db.num_cols()) {
+            throw std::runtime_error(
+                "[ivf_index] ibin >= shuffled_db.num_cols()");
+          }
           for (size_t j = 0; j < db.num_rows(); ++j) {
             shuffled_db(j, ibin) = db(j, i);
           }

src/include/detail/ivf/qv.h

@@ -132,7 +132,11 @@ auto qv_query_heap_infinite_ram(
         [&, nprobe](auto&& q_vec, auto&& n = 0, auto&& j = 0) {
           for (size_t p = 0; p < nprobe; ++p) {
             auto aa = top_centroids(p, j);
-            assert(top_centroids(p, j) < size(indices) - 1);
+            if (top_centroids(p, j) >= size(indices) - 1) {
+              throw std::runtime_error(
+                  "[qv_query_heap_infinite_ram] top_centroids(p, j) >= "
+                  "size(indices) - 1");
+            }
 
             size_t start = indices[top_centroids(p, j)];
             size_t stop = indices[top_centroids(p, j) + 1];
@@ -648,7 +652,11 @@ auto nuv_query_heap_finite_ram_reg_blocked(
                     p +
                     part_offset;  // resident_part_offset(partitioned_vectors);
 
-                assert(p + 1 < size(indices));
+                if (p + 1 >= size(indices)) {
+                  throw std::runtime_error(
+                      "[nuv_query_heap_finite_ram_reg_blocked] p + 1 >= "
+                      "size(indices)");
+                }
 
                 auto start = indices[p];
                 auto stop = indices[p + 1];