Decouple C++ library from C library (#1488)

Currently, the C++ library needs C headers to build and be installed at runtime (as it was leaking those headers). This is unnecessary circular dependency and as the only C header needed by the C++ library was that of `cuvs/distance/distance.h`, it was easily resolved. As precedent has been set already, we declare an `enum` first in C++ and then create a duplicate of it in C, and cast between the two when calling the C++ API from the C API.

Authors:
  - Divye Gala (https://github.com/divyegala)

Approvers:
  - Robert Maynard (https://github.com/robertmaynard)
  - Tarang Jain (https://github.com/tarang-jain)

URL: #1488

Author: divyegala

c/src/cluster/kmeans.cpp

@@ -18,7 +18,7 @@ namespace {
 cuvs::cluster::kmeans::params convert_params(const cuvsKMeansParams& params)
 {
   auto kmeans_params       = cuvs::cluster::kmeans::params();
-  kmeans_params.metric     = params.metric;
+  kmeans_params.metric     = static_cast<cuvs::distance::DistanceType>(params.metric);
   kmeans_params.init       = static_cast<cuvs::cluster::kmeans::params::InitMethod>(params.init);
   kmeans_params.n_clusters = params.n_clusters;
   kmeans_params.max_iter   = params.max_iter;
@@ -33,7 +33,7 @@ cuvs::cluster::kmeans::params convert_params(const cuvsKMeansParams& params)
 cuvs::cluster::kmeans::balanced_params convert_balanced_params(const cuvsKMeansParams& params)
 {
   auto kmeans_params    = cuvs::cluster::kmeans::balanced_params();
-  kmeans_params.metric  = params.metric;
+  kmeans_params.metric  = static_cast<cuvs::distance::DistanceType>(params.metric);
   kmeans_params.n_iters = params.hierarchical_n_iters;
   return kmeans_params;
 }
@@ -185,7 +185,7 @@ extern "C" cuvsError_t cuvsKMeansParamsCreate(cuvsKMeansParams_t* params)
     cuvs::cluster::kmeans::params cpp_params;
     cuvs::cluster::kmeans::balanced_params cpp_balanced_params;
     *params =
-      new cuvsKMeansParams{.metric     = cpp_params.metric,
+      new cuvsKMeansParams{.metric     = static_cast<cuvsDistanceType>(cpp_params.metric),
                            .n_clusters = cpp_params.n_clusters,
                            .init       = static_cast<cuvsKMeansInitMethod>(cpp_params.init),
                            .max_iter   = cpp_params.max_iter,

c/src/distance/pairwise_distance.cpp

@@ -12,6 +12,7 @@
 #include <raft/core/resources.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
 #include <cuvs/distance/distance.hpp>
 
 #include "../core/exceptions.hpp"
@@ -35,8 +36,9 @@ void _pairwise_distance(cuvsResources_t res,
   auto x_mds         = cuvs::core::from_dlpack<mdspan_type>(x_tensor);
   auto y_mds         = cuvs::core::from_dlpack<mdspan_type>(y_tensor);
   auto distances_mds = cuvs::core::from_dlpack<distances_mdspan_type>(distances_tensor);
+  auto metric_type   = static_cast<cuvs::distance::DistanceType>(metric);
 
-  cuvs::distance::pairwise_distance(*res_ptr, x_mds, y_mds, distances_mds, metric, metric_arg);
+  cuvs::distance::pairwise_distance(*res_ptr, x_mds, y_mds, distances_mds, metric_type, metric_arg);
 }
 }  // namespace
 

c/src/neighbors/all_neighbors.cpp

@@ -11,6 +11,7 @@
 #include <raft/util/cudart_utils.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/all_neighbors.h>
 #include <cuvs/neighbors/ivf_pq.h>
 #include <cuvs/neighbors/nn_descent.h>

c/src/neighbors/brute_force.cpp

@@ -14,6 +14,8 @@
 #include <raft/core/serialize.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/brute_force.h>
 #include <cuvs/neighbors/common.h>
 #include <cuvs/neighbors/brute_force.hpp>
@@ -35,7 +37,7 @@ void* _build(cuvsResources_t res,
   auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
 
   cuvs::neighbors::brute_force::index_params params;
-  params.metric     = metric;
+  params.metric     = static_cast<cuvs::distance::DistanceType>((int)metric);
   params.metric_arg = metric_arg;
 
   auto index_on_stack = cuvs::neighbors::brute_force::build(*res_ptr, params, mds);

c/src/neighbors/cagra.cpp

@@ -12,6 +12,8 @@
 #include <raft/core/serialize.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/cagra.h>
 #include <cuvs/neighbors/common.h>
 #include <cuvs/neighbors/cagra.hpp>

c/src/neighbors/hnsw.cpp

@@ -14,6 +14,7 @@
 
 #include <cuvs/core/c_api.h>
 #include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/hnsw.h>
 #include <cuvs/neighbors/hnsw.hpp>
 
@@ -110,8 +111,9 @@ void* _deserialize(cuvsResources_t res,
   cuvs::neighbors::hnsw::index<T>* index = nullptr;
   auto cpp_params                        = cuvs::neighbors::hnsw::index_params();
   cpp_params.hierarchy = static_cast<cuvs::neighbors::hnsw::HnswHierarchy>(params->hierarchy);
+  auto metric_type     = static_cast<cuvs::distance::DistanceType>(metric);
   cuvs::neighbors::hnsw::deserialize(
-    *res_ptr, cpp_params, std::string(filename), dim, metric, &index);
+    *res_ptr, cpp_params, std::string(filename), dim, metric_type, &index);
   return index;
 }
 }  // namespace

c/src/neighbors/nn_descent.cpp

@@ -15,6 +15,7 @@
 #include <raft/util/cudart_utils.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
 #include <cuvs/neighbors/nn_descent.h>
 #include <cuvs/neighbors/nn_descent.hpp>
 
@@ -170,7 +171,7 @@ extern "C" cuvsError_t cuvsNNDescentIndexParamsCreate(cuvsNNDescentIndexParams_t
     cuvs::neighbors::nn_descent::index_params cpp_params;
 
     *params = new cuvsNNDescentIndexParams{
-      .metric                    = cpp_params.metric,
+      .metric                    = static_cast<cuvsDistanceType>((int)cpp_params.metric),
       .metric_arg                = cpp_params.metric_arg,
       .graph_degree              = cpp_params.graph_degree,
       .intermediate_graph_degree = cpp_params.intermediate_graph_degree,

c/src/neighbors/refine.cpp

@@ -11,6 +11,8 @@
 #include <raft/core/resources.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/refine.h>
 #include <cuvs/neighbors/refine.hpp>
 
@@ -41,7 +43,7 @@ void _refine(bool on_device,
     auto candidates       = cuvs::core::from_dlpack<candidates_type>(candidates_tensor);
     auto indices          = cuvs::core::from_dlpack<indices_type>(indices_tensor);
     auto distances        = cuvs::core::from_dlpack<distances_type>(distances_tensor);
-    cuvs::neighbors::refine(*res_ptr, dataset, queries, candidates, indices, distances, metric);
+    cuvs::neighbors::refine(*res_ptr, dataset, queries, candidates, indices, distances, static_cast<cuvs::distance::DistanceType>((int)metric));
   } else {
     using queries_type    = raft::host_matrix_view<const T, int64_t, raft::row_major>;
     using candidates_type = raft::host_matrix_view<const int64_t, int64_t, raft::row_major>;
@@ -52,7 +54,7 @@ void _refine(bool on_device,
     auto candidates       = cuvs::core::from_dlpack<candidates_type>(candidates_tensor);
     auto indices          = cuvs::core::from_dlpack<indices_type>(indices_tensor);
     auto distances        = cuvs::core::from_dlpack<distances_type>(distances_tensor);
-    cuvs::neighbors::refine(*res_ptr, dataset, queries, candidates, indices, distances, metric);
+    cuvs::neighbors::refine(*res_ptr, dataset, queries, candidates, indices, distances, static_cast<cuvs::distance::DistanceType>((int)metric));
   }
 }
 }  // namespace

c/src/neighbors/tiered_index.cpp

@@ -12,6 +12,8 @@
 #include <raft/core/serialize.hpp>
 
 #include <cuvs/core/c_api.h>
+#include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 #include <cuvs/neighbors/tiered_index.h>
 #include <cuvs/neighbors/tiered_index.hpp>
 
@@ -35,7 +37,7 @@ void convert_c_index_params(cuvsTieredIndexParams params,
 {
   out->min_ann_rows               = params.min_ann_rows;
   out->create_ann_index_on_extend = params.create_ann_index_on_extend;
-  out->metric                     = params.metric;
+  out->metric                     = static_cast<cuvs::distance::DistanceType>((int)params.metric);
 
   if constexpr (std::is_same_v<T, cagra::index_params>) {
     if (params.cagra_params != NULL) {
@@ -314,7 +316,7 @@ extern "C" cuvsError_t cuvsTieredIndexParamsCreate(cuvsTieredIndexParams_t* para
   return cuvs::core::translate_exceptions([=] {
     cuvs::neighbors::tiered_index::index_params<cagra::index_params> cpp_params;
     *params = new cuvsTieredIndexParams{
-      .metric                     = cpp_params.metric,
+      .metric                     = static_cast<cuvsDistanceType>((int)cpp_params.metric),
       .algo                       = CUVS_TIERED_INDEX_ALGO_CAGRA,
       .min_ann_rows               = cpp_params.min_ann_rows,
       .create_ann_index_on_extend = cpp_params.create_ann_index_on_extend};

c/tests/neighbors/brute_force_c.cu

@@ -161,11 +161,11 @@ void cpu_sddmm(value_t* A,
         norms_B += B[b_index] * B[b_index];
       }
       vals[j] = alpha * sum + beta * vals[j];
-      if (metric == cuvs::distance::DistanceType::L2Expanded) {
+      if (metric == L2Expanded) {
         vals[j] = value_t(-2.0) * vals[j] + norms_A + norms_B;
-      } else if (metric == cuvs::distance::DistanceType::L2SqrtExpanded) {
+      } else if (metric == L2SqrtExpanded) {
         vals[j] = std::sqrt(value_t(-2.0) * vals[j] + norms_A + norms_B);
-      } else if (metric == cuvs::distance::DistanceType::CosineExpanded) {
+      } else if (metric == CosineExpanded) {
         vals[j] = value_t(1.0) - vals[j] / std::sqrt(norms_A * norms_B);
       }
     }
@@ -306,7 +306,7 @@ void recall_eval(T* query_data,
     n_rows,
     n_dim,
     n_neighbors,
-    static_cast<cuvs::distance::DistanceType>((uint16_t)metric));
+    static_cast<cuvs::distance::DistanceType>((int)metric));
 
   size_t size = n_queries * n_neighbors;
   std::vector<IdxT> neighbors_h(size);
@@ -363,7 +363,7 @@ void recall_eval_with_filter(T* query_data,
   raft::copy(queries_h.data(), query_data, n_queries * n_dim, stream);
   raft::copy(indices_h.data(), index_data, n_rows * n_dim, stream);
 
-  bool select_min = cuvs::distance::is_min_close(metric);
+  bool select_min = cuvs::distance::is_min_close(static_cast<cuvs::distance::DistanceType>((int)metric));
 
   cpu_brute_force_with_filter(queries_h.data(),
                               indices_h.data(),
@@ -377,7 +377,7 @@ void recall_eval_with_filter(T* query_data,
                               n_neighbors,
                               nnz,
                               select_min,
-                              static_cast<cuvs::distance::DistanceType>((uint16_t)metric));
+                              metric);
 
   // verify output
   double min_recall = 0.95;
@@ -453,7 +453,7 @@ void run_test_with_filter(int64_t n_samples,
   int64_t nnz = create_sparse_matrix(n_rows_filter, n_samples, sparsity, filter_h);
 
   cuvsDistanceType metric = L2Expanded;
-  bool select_min         = cuvs::distance::is_min_close(metric);
+  bool select_min         = cuvs::distance::is_min_close(static_cast<cuvs::distance::DistanceType>((int)metric));
 
   std::vector<float> distances_ref_h(
     n_queries * n_neighbors,