Remove specializations and split expensive headers

README.md

@@ -198,7 +198,7 @@ RAFT itself can be installed through conda, [CMake Package Manager (CPM)](https:
 
 The easiest way to install RAFT is through conda and several packages are provided.
 - `libraft-headers` RAFT headers
-- `libraft` (optional) shared library of pre-compiled template specializations and runtime APIs.
+- `libraft` (optional) shared library of pre-compiled template instantiations and runtime APIs.
 - `pylibraft` (optional) Python wrappers around RAFT algorithms and primitives.
 - `raft-dask` (optional) enables deployment of multi-node multi-GPU algorithms that use RAFT `raft::comms` in Dask clusters.
 
@@ -231,11 +231,11 @@ You can find an [example RAFT](cpp/template/README.md) project template in the `
 
 Additional CMake targets can be made available by adding components in the table below to the `RAFT_COMPONENTS` list above, separated by spaces. The `raft::raft` target will always be available. RAFT headers require, at a minimum, the CUDA toolkit libraries and RMM dependencies.
 
-| Component | Target | Description  | Base Dependencies |
-|-------------|---------------------|-----------------------------------------------------------|---------------------------------------|
-| n/a | `raft::raft` | Full RAFT header library  | CUDA toolkit, RMM, NVTX, CCCL, CUTLASS |
-| compiled | `raft::compiled` | Pre-compiled template specializations and runtime library | raft::raft |
-| distributed | `raft::distributed` | Dependencies for `raft::comms` APIs  | raft::raft, UCX, NCCL |
+| Component | Target | Description | Base Dependencies  |
+|-------------|---------------------|----------------------------------------------------------|----------------------------------------|
+| n/a | `raft::raft` | Full RAFT header library | CUDA toolkit, RMM, NVTX, CCCL, CUTLASS |
+| compiled | `raft::compiled` | Pre-compiled template instantiations and runtime library | raft::raft  |
+| distributed | `raft::distributed` | Dependencies for `raft::comms` APIs | raft::raft, UCX, NCCL  |
 
 ### Source
 
@@ -282,7 +282,7 @@ The folder structure mirrors other RAPIDS repos, with the following folders:
  - `util`: Various reusable tools and utilities for accelerated algorithm development
  - `internal`: A private header-only component that hosts the code shared between benchmarks and tests.
  - `scripts`: Helpful scripts for development
- - `src`: Compiled APIs and template specializations for the shared libraries
+ - `src`: Compiled APIs and template instantiations for the shared libraries
  - `template`: A skeleton template containing the bare-bones file structure and cmake configuration for writing applications with RAFT.
  - `test`: Googletests source code
 - `docs`: Source code and scripts for building library documentation (Uses breath, doxygen, & pydocs)

cpp/bench/ann/src/raft/raft_benchmark.cu

@@ -22,10 +22,6 @@
 #include <type_traits>
 #include <utility>
 
-#ifdef RAFT_COMPILED
-#include <raft/neighbors/specializations.cuh>
-#endif
-
 #include "../common/ann_types.hpp"
 #include "../common/benchmark_util.hpp"
 #undef WARP_SIZE
@@ -220,4 +216,4 @@ std::unique_ptr<typename raft::bench::ann::ANN<T>::AnnSearchParam> create_search
 
 #include "../common/benchmark.hpp"
 
-int main(int argc, char** argv) { return raft::bench::ann::run_main(argc, argv); }
+int main(int argc, char** argv) { return raft::bench::ann::run_main(argc, argv); }

cpp/bench/ann/src/raft/raft_ivf_flat.cu

@@ -15,12 +15,8 @@
  */
 #include "raft_ivf_flat_wrapper.h"
 
-#ifdef RAFT_COMPILED
-#include <raft/neighbors/specializations.cuh>
-#endif
-
 namespace raft::bench::ann {
 template class RaftIvfFlatGpu<float, int64_t>;
 template class RaftIvfFlatGpu<uint8_t, int64_t>;
 template class RaftIvfFlatGpu<int8_t, int64_t>;
-} // namespace raft::bench::ann
+} // namespace raft::bench::ann

cpp/bench/ann/src/raft/raft_ivf_flat_wrapper.h

@@ -29,6 +29,7 @@
 #include <raft/neighbors/ivf_flat_types.hpp>
 #include <raft/util/cudart_utils.hpp>
 #include <rmm/device_uvector.hpp>
+#include <rmm/mr/device/pool_memory_resource.hpp>
 #include <stdexcept>
 #include <string>
 #include <type_traits>

cpp/bench/ann/src/raft/raft_ivf_pq.cu

@@ -15,10 +15,6 @@
  */
 #include "raft_ivf_pq_wrapper.h"
 
-#ifdef RAFT_COMPILED
-#include <raft/neighbors/specializations.cuh>
-#endif
-
 namespace raft::bench::ann {
 template class RaftIvfPQ<float, int64_t>;
 template class RaftIvfPQ<uint8_t, int64_t>;

cpp/bench/prims/CMakeLists.txt

@@ -54,6 +54,7 @@ function(ConfigureBench)
  ${BENCH_NAME} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${RAFT_CXX_FLAGS}>"
  "$<$<COMPILE_LANGUAGE:CUDA>:${RAFT_CUDA_FLAGS}>"
  )
+ target_compile_definitions(${BENCH_NAME} PRIVATE "RAFT_EXPLICIT_INSTANTIATE_ONLY")
 
  target_include_directories(
  ${BENCH_NAME} PUBLIC "$<BUILD_INTERFACE:${RAFT_SOURCE_DIR}/bench/prims>"
@@ -140,4 +141,11 @@ if(BUILD_PRIMS_BENCH)
  OPTIONAL
  LIB
  )
+
+ add_custom_target(ALL_BENCH)
+ add_dependencies(
+ ALL_BENCH CLUSTER_BENCH DISTANCE_BENCH LINALG_BENCH MATRIX_BENCH NEIGHBORS_BENCH RANDOM_BENCH
+ SPARSE_BENCH TUNE_DISTANCE
+ )
+
 endif()

cpp/bench/prims/cluster/kmeans.cu

@@ -18,10 +18,6 @@
 #include <raft/cluster/kmeans.cuh>
 #include <raft/cluster/kmeans_types.hpp>
 
-#if defined RAFT_COMPILED
-#include <raft/cluster/specializations.cuh>
-#endif
-
 namespace raft::bench::cluster {
 
 struct KMeansBenchParams {

cpp/bench/prims/cluster/kmeans_balanced.cu

@@ -18,10 +18,6 @@
 #include <raft/cluster/kmeans_balanced.cuh>
 #include <raft/random/rng.cuh>
 
-#if defined RAFT_COMPILED
-#include <raft/cluster/specializations.cuh>
-#endif
-
 namespace raft::bench::cluster {
 
 struct KMeansBalancedBenchParams {

cpp/bench/prims/distance/distance_common.cuh

@@ -17,9 +17,6 @@
 #include <common/benchmark.hpp>
 #include <raft/distance/distance.cuh>
 #include <raft/util/cudart_utils.hpp>
-#if defined RAFT_COMPILED
-#include <raft/distance/specializations.cuh>
-#endif
 #include <rmm/device_uvector.hpp>
 
 namespace raft::bench::distance {

cpp/bench/prims/distance/fused_l2_nn.cu

@@ -16,10 +16,8 @@
 
 #include <common/benchmark.hpp>
 #include <raft/distance/fused_l2_nn.cuh>
+#include <raft/linalg/norm.cuh>
 #include <raft/util/cudart_utils.hpp>
-#if defined RAFT_COMPILED
-#include <raft/distance/specializations.cuh>
-#endif
 #include <rmm/device_uvector.hpp>
 
 namespace raft::bench::distance {

cpp/bench/prims/distance/kernels.cu

@@ -13,10 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#if defined RAFT_COMPILED
-#include <raft/distance/specializations.cuh>
-#endif
-
 #include <common/benchmark.hpp>
 #include <memory>
 #include <raft/core/device_resources.hpp>

cpp/bench/prims/distance/masked_nn.cu

@@ -25,15 +25,12 @@
 #include <raft/core/device_mdarray.hpp>
 #include <raft/core/device_mdspan.hpp>
 #include <raft/core/handle.hpp>
+#include <raft/distance/detail/fused_l2_nn.cuh> // MinAndDistanceReduceOpImpl
 #include <raft/distance/masked_nn.cuh>
 #include <raft/linalg/norm.cuh>
 #include <raft/random/rng.cuh>
 #include <raft/util/cudart_utils.hpp>
 
-#ifdef RAFT_COMPILED
-#include <raft/distance/specializations.cuh>
-#endif
-
 namespace raft::bench::distance::masked_nn {
 
 // Introduce various sparsity patterns
@@ -95,8 +92,8 @@ struct masked_l2_nn : public fixture {
  using DataT = T;
  using IdxT = int;
  using OutT = raft::KeyValuePair<IdxT, DataT>;
- using RedOpT = raft::distance::MinAndDistanceReduceOp<int, DataT>;
- using PairRedOpT = raft::distance::KVPMinReduce<int, DataT>;
+ using RedOpT = raft::distance::detail::MinAndDistanceReduceOpImpl<int, DataT>;
+ using PairRedOpT = raft::distance::detail::KVPMinReduceImpl<int, DataT>;
  using ParamT = raft::distance::masked_l2_nn_params<RedOpT, PairRedOpT>;
 
  // Parameters
@@ -126,8 +123,9 @@ struct masked_l2_nn : public fixture {
  xn.data_handle(), x.data_handle(), p.k, p.m, raft::linalg::L2Norm, true, stream);
  raft::linalg::rowNorm(
  yn.data_handle(), y.data_handle(), p.k, p.n, raft::linalg::L2Norm, true, stream);
- raft::distance::initialize<T, raft::KeyValuePair<int, T>, int>(
- handle, out.data_handle(), p.m, std::numeric_limits<T>::max(), RedOpT{});
+ // Avoid instantiating raft::distance::initialize..
+ raft::distance::detail::initialize<T, raft::KeyValuePair<int, T>, int>(
+ out.data_handle(), p.m, std::numeric_limits<T>::max(), RedOpT{}, handle.get_stream());
 
  dim3 block(32, 32);
  dim3 grid(10, 10);

cpp/bench/prims/matrix/select_k.cu

@@ -23,10 +23,6 @@
 #include <raft/sparse/detail/utils.h>
 #include <raft/util/cudart_utils.hpp>
 
-#if defined RAFT_COMPILED
-#include <raft/matrix/specializations.cuh>
-#endif
-
 #include <raft/matrix/detail/select_radix.cuh>
 #include <raft/matrix/detail/select_warpsort.cuh>
 #include <raft/matrix/select_k.cuh>

cpp/bench/prims/neighbors/knn.cuh

@@ -24,10 +24,6 @@
 #include <raft/neighbors/ivf_pq.cuh>
 #include <raft/spatial/knn/knn.cuh>
 
-#if defined RAFT_COMPILED
-#include <raft/neighbors/specializations.cuh>
-#endif
-
 #include <rmm/mr/device/managed_memory_resource.hpp>
 #include <rmm/mr/device/per_device_resource.hpp>
 

cpp/bench/prims/neighbors/refine_float_int64_t.cu

@@ -17,11 +17,6 @@
 #include "refine.cuh"
 #include <common/benchmark.hpp>
 
-#if defined RAFT_COMPILED
-#include <raft/neighbors/specializations/refine.cuh>
-#include <raft/spatial/knn/specializations.cuh>
-#endif
-
 using namespace raft::neighbors;
 
 namespace raft::bench::neighbors {

cpp/bench/prims/neighbors/refine_uint8_t_int64_t.cu

@@ -17,10 +17,6 @@
 #include "refine.cuh"
 #include <common/benchmark.hpp>
 
-#if defined RAFT_COMPILED
-#include <raft/neighbors/specializations.cuh>
-#endif
-
 using namespace raft::neighbors;
 
 namespace raft::bench::neighbors {

cpp/doxygen/Doxyfile

@@ -918,6 +918,7 @@ EXCLUDE_SYMLINKS = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
+# TODO: remove specializations from exclude patterns when headers have been removed.
 EXCLUDE_PATTERNS = */detail/* \
  */specializations/* \
  */thirdparty/*

cpp/include/raft/cluster/detail/kmeans_common.cuh

@@ -38,6 +38,7 @@
 #include <raft/distance/distance.cuh>
 #include <raft/distance/distance_types.hpp>
 #include <raft/distance/fused_l2_nn.cuh>
+#include <raft/linalg/norm.cuh>
 #include <raft/linalg/reduce_rows_by_key.cuh>
 #include <raft/linalg/unary_op.cuh>
 #include <raft/matrix/gather.cuh>

cpp/include/raft/cluster/specializations.cuh

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef __CLUSTER_SPECIALIZATIONS_H
-#define __CLUSTER_SPECIALIZATIONS_H
-
 #pragma once
 
-#include <raft/distance/specializations.cuh>
-#include <raft/neighbors/specializations.cuh>
-
-#endif
+#pragma message( \
+ __FILE__ \
+ " is deprecated and will be removed." \
+ " Including specializations is not necessary any more." \
+ " For more information, see: https://docs.rapids.ai/api/raft/nightly/using_libraft.html")