diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8e1c65f4b4..c2c9f83eeb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@
 - PR #2996: Removing the max_depth restriction for switching to the batched backend
 - PR #3004: Remove Single Process Multi GPU (SPMG) code
 - PR #3044: Move leftover `linalg` and `stats` to RAFT namespaces
+- PR #3067: Deleting prims moved to RAFT and updating header paths
 - PR #3074: Reducing dask coordinate descent test runtime
 
 ## Bug Fixes
diff --git a/cpp/bench/common/ml_benchmark.hpp b/cpp/bench/common/ml_benchmark.hpp
index 678c32da52..a205256cda 100644
--- a/cpp/bench/common/ml_benchmark.hpp
+++ b/cpp/bench/common/ml_benchmark.hpp
@@ -17,8 +17,8 @@
 #pragma once
 
 #include <benchmark/benchmark.h>
-#include <common/cudart_utils.h>
 #include <cuda_runtime.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/common/logger.hpp>
 #include <cuml/common/utils.hpp>
diff --git a/cpp/bench/prims/add.cu b/cpp/bench/prims/add.cu
index 797019b574..c89c7413d4 100644
--- a/cpp/bench/prims/add.cu
+++ b/cpp/bench/prims/add.cu
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <linalg/add.cuh>
+#include <raft/linalg/add.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/distance_common.cuh b/cpp/bench/prims/distance_common.cuh
index 6e8ca6460e..112d17d18f 100644
--- a/cpp/bench/prims/distance_common.cuh
+++ b/cpp/bench/prims/distance_common.cuh
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <distance/distance.cuh>
 #include "../common/ml_benchmark.hpp"
 
diff --git a/cpp/bench/prims/fused_l2_nn.cu b/cpp/bench/prims/fused_l2_nn.cu
index f58fcbfdb4..60a2a6cfaa 100644
--- a/cpp/bench/prims/fused_l2_nn.cu
+++ b/cpp/bench/prims/fused_l2_nn.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <distance/fused_l2_nn.cuh>
 #include <limits>
-#include <linalg/norm.cuh>
-#include <random/rng.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/random/rng.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/gram_matrix.cu b/cpp/bench/prims/gram_matrix.cu
index 3f705bc6a6..f8cbf664c6 100644
--- a/cpp/bench/prims/gram_matrix.cu
+++ b/cpp/bench/prims/gram_matrix.cu
@@ -18,7 +18,7 @@
 #include <matrix/grammatrix.cuh>
 #include <matrix/kernelfactory.cuh>
 #include <memory>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include <sstream>
 #include <string>
 #include <vector>
diff --git a/cpp/bench/prims/map_then_reduce.cu b/cpp/bench/prims/map_then_reduce.cu
index 779474cf8d..2bd8bf2501 100644
--- a/cpp/bench/prims/map_then_reduce.cu
+++ b/cpp/bench/prims/map_then_reduce.cu
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <linalg/map_then_reduce.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/matrix_vector_op.cu b/cpp/bench/prims/matrix_vector_op.cu
index b03fe6ce6e..4dd7a3ea75 100644
--- a/cpp/bench/prims/matrix_vector_op.cu
+++ b/cpp/bench/prims/matrix_vector_op.cu
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <linalg/matrix_vector_op.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/permute.cu b/cpp/bench/prims/permute.cu
index 32de6f62fe..8d3b8f1157 100644
--- a/cpp/bench/prims/permute.cu
+++ b/cpp/bench/prims/permute.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
 #include <random/permute.cuh>
-#include <random/rng.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/reduce.cu b/cpp/bench/prims/reduce.cu
index 8b0ed01522..0ed557ab71 100644
--- a/cpp/bench/prims/reduce.cu
+++ b/cpp/bench/prims/reduce.cu
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <linalg/reduce.cuh>
+#include <raft/linalg/reduce.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/prims/rng.cu b/cpp/bench/prims/rng.cu
index 3a5c29395b..af1281eb0e 100644
--- a/cpp/bench/prims/rng.cu
+++ b/cpp/bench/prims/rng.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
 #include "../common/ml_benchmark.hpp"
 
 namespace MLCommon {
diff --git a/cpp/bench/sg/arima_loglikelihood.cu b/cpp/bench/sg/arima_loglikelihood.cu
index e019b58bf6..d13e859e49 100644
--- a/cpp/bench/sg/arima_loglikelihood.cu
+++ b/cpp/bench/sg/arima_loglikelihood.cu
@@ -22,9 +22,9 @@
 
 #include <cuml/tsa/arima_common.h>
 #include <cuml/tsa/batched_arima.hpp>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "benchmark.cuh"
 
 namespace ML {
diff --git a/cpp/bench/sg/benchmark.cuh b/cpp/bench/sg/benchmark.cuh
index 6f65e4d469..2669b79019 100644
--- a/cpp/bench/sg/benchmark.cuh
+++ b/cpp/bench/sg/benchmark.cuh
@@ -17,8 +17,8 @@
 #pragma once
 
 #include <benchmark/benchmark.h>
-#include <common/cudart_utils.h>
 #include <cuda_runtime.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/logger.hpp>
 #include <cuml/cuml.hpp>
 #include "../common/ml_benchmark.hpp"
diff --git a/cpp/bench/sg/dataset.cuh b/cpp/bench/sg/dataset.cuh
index ba85316a0e..ce9d243a85 100644
--- a/cpp/bench/sg/dataset.cuh
+++ b/cpp/bench/sg/dataset.cuh
@@ -16,15 +16,15 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/cuml.hpp>
 #include <cuml/datasets/make_blobs.hpp>
 #include <fstream>
 #include <iostream>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include <random/make_regression.cuh>
 #include <sstream>
 #include <string>
diff --git a/cpp/bench/sg/dataset_ts.cuh b/cpp/bench/sg/dataset_ts.cuh
index bdabe6561b..b43029d22b 100644
--- a/cpp/bench/sg/dataset_ts.cuh
+++ b/cpp/bench/sg/dataset_ts.cuh
@@ -17,11 +17,11 @@
 #pragma once
 
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/cuml.hpp>
+#include <raft/cuda_utils.cuh>
 
-#include <common/cudart_utils.h>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
 
 namespace ML {
 namespace Bench {
diff --git a/cpp/bench/sg/umap.cu b/cpp/bench/sg/umap.cu
index 4577017630..d7ddb31552 100644
--- a/cpp/bench/sg/umap.cu
+++ b/cpp/bench/sg/umap.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <cuda_utils.cuh>
 #include <cuml/cuml.hpp>
 #include <cuml/manifold/umap.hpp>
+#include <raft/cuda_utils.cuh>
 #include <utility>
 #include "benchmark.cuh"
 
diff --git a/cpp/cmake/Dependencies.cmake b/cpp/cmake/Dependencies.cmake
index 804a9de685..ffa014641b 100644
--- a/cpp/cmake/Dependencies.cmake
+++ b/cpp/cmake/Dependencies.cmake
@@ -39,7 +39,7 @@ else(DEFINED ENV{RAFT_PATH})
 
   ExternalProject_Add(raft
     GIT_REPOSITORY    https://github.com/rapidsai/raft.git
-    GIT_TAG           3f8a4bf6f81289f1fdaae9a5bd4a10de8674aa5c
+    GIT_TAG           9b3afe67895fbea397fb2c72375157aadfc132d8
     PREFIX            ${RAFT_DIR}
     CONFIGURE_COMMAND ""
     BUILD_COMMAND     ""
diff --git a/cpp/include/cuml/tsa/arima_common.h b/cpp/include/cuml/tsa/arima_common.h
index 43d3b364d0..e2220727e8 100644
--- a/cpp/include/cuml/tsa/arima_common.h
+++ b/cpp/include/cuml/tsa/arima_common.h
@@ -20,7 +20,7 @@
 
 #include <algorithm>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <thrust/execution_policy.h>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
diff --git a/cpp/src/arima/batched_arima.cu b/cpp/src/arima/batched_arima.cu
index 6274a783ff..3b7570fdf9 100644
--- a/cpp/src/arima/batched_arima.cu
+++ b/cpp/src/arima/batched_arima.cu
@@ -28,14 +28,14 @@
 #include <cuml/tsa/batched_arima.hpp>
 #include <cuml/tsa/batched_kalman.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/nvtx.hpp>
-#include <cuda_utils.cuh>
 #include <linalg/batched/matrix.cuh>
-#include <linalg/matrix_vector_op.cuh>
 #include <metrics/batched/information_criterion.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
 #include <timeSeries/arima_helpers.cuh>
 
 namespace ML {
diff --git a/cpp/src/arima/batched_kalman.cu b/cpp/src/arima/batched_kalman.cu
index cbde9b7729..932f50d07c 100644
--- a/cpp/src/arima/batched_kalman.cu
+++ b/cpp/src/arima/batched_kalman.cu
@@ -24,14 +24,14 @@
 #include <cuml/cuml.hpp>
 #include <cuml/tsa/batched_kalman.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/nvtx.hpp>
-#include <cuda_utils.cuh>
 #include <linalg/batched/matrix.cuh>
-#include <linalg/binary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
 #include <sparse/batched/csr.cuh>
 #include <timeSeries/arima_helpers.cuh>
 
diff --git a/cpp/src/common/allocatorAdapter.hpp b/cpp/src/common/allocatorAdapter.hpp
index 7d1a8b9997..06aaf879d7 100644
--- a/cpp/src/common/allocatorAdapter.hpp
+++ b/cpp/src/common/allocatorAdapter.hpp
@@ -22,7 +22,7 @@
 
 #include <cuml/cuml.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/cuml_allocator.hpp>
 
 namespace ML {
diff --git a/cpp/src/common/cumlHandle.cpp b/cpp/src/common/cumlHandle.cpp
index d704f037f3..c4697c14b5 100644
--- a/cpp/src/common/cumlHandle.cpp
+++ b/cpp/src/common/cumlHandle.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "cumlHandle.hpp"
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <raft/sparse/cusparse_wrappers.h>
diff --git a/cpp/src/common/cuml_api.cpp b/cpp/src/common/cuml_api.cpp
index 802c71ca93..fb66ff78ab 100644
--- a/cpp/src/common/cuml_api.cpp
+++ b/cpp/src/common/cuml_api.cpp
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/cuml_api.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/utils.hpp>
 #include <functional>
 #include <raft/mr/device/allocator.hpp>
diff --git a/cpp/src/common/tensor.hpp b/cpp/src/common/tensor.hpp
index e08de1e89c..5646d421c2 100644
--- a/cpp/src/common/tensor.hpp
+++ b/cpp/src/common/tensor.hpp
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/cuml_allocator.hpp>
 #include <vector>
 
diff --git a/cpp/src/dbscan/adjgraph/algo.cuh b/cpp/src/dbscan/adjgraph/algo.cuh
index e9146a9a45..f80a827d7c 100644
--- a/cpp/src/dbscan/adjgraph/algo.cuh
+++ b/cpp/src/dbscan/adjgraph/algo.cuh
@@ -20,7 +20,7 @@
 #include <thrust/scan.h>
 #include <common/allocatorAdapter.hpp>
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "../common.cuh"
 #include "pack.h"
 
diff --git a/cpp/src/dbscan/adjgraph/naive.cuh b/cpp/src/dbscan/adjgraph/naive.cuh
index 982fdad4fd..ae44f5a59e 100644
--- a/cpp/src/dbscan/adjgraph/naive.cuh
+++ b/cpp/src/dbscan/adjgraph/naive.cuh
@@ -16,10 +16,10 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/host_buffer.hpp>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "../common.cuh"
 #include "pack.h"
 
diff --git a/cpp/src/dbscan/dbscan.cu b/cpp/src/dbscan/dbscan.cu
index 6ef1ed5077..7f8ae9e286 100644
--- a/cpp/src/dbscan/dbscan.cu
+++ b/cpp/src/dbscan/dbscan.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <cuml/cuml_api.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <cuml/cluster/dbscan.hpp>
 #include "dbscan.cuh"
diff --git a/cpp/src/dbscan/runner.cuh b/cpp/src/dbscan/runner.cuh
index 91aa982024..1f0a5c7f8d 100644
--- a/cpp/src/dbscan/runner.cuh
+++ b/cpp/src/dbscan/runner.cuh
@@ -16,12 +16,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/nvtx.hpp>
-#include <cuda_utils.cuh>
 #include <label/classlabels.cuh>
+#include <raft/cuda_utils.cuh>
 #include <sparse/csr.cuh>
 #include "adjgraph/runner.cuh"
 #include "vertexdeg/runner.cuh"
diff --git a/cpp/src/dbscan/vertexdeg/naive.cuh b/cpp/src/dbscan/vertexdeg/naive.cuh
index c2a30dd35f..db239711e9 100644
--- a/cpp/src/dbscan/vertexdeg/naive.cuh
+++ b/cpp/src/dbscan/vertexdeg/naive.cuh
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "pack.h"
 
 namespace Dbscan {
diff --git a/cpp/src/decisiontree/batched-levelalgo/builder_base.cuh b/cpp/src/decisiontree/batched-levelalgo/builder_base.cuh
index 1dcc9964c8..40a3720915 100644
--- a/cpp/src/decisiontree/batched-levelalgo/builder_base.cuh
+++ b/cpp/src/decisiontree/batched-levelalgo/builder_base.cuh
@@ -21,8 +21,8 @@
 #include <common/device_buffer.hpp>
 #include <common/grid_sync.cuh>
 #include <common/host_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/tree/decisiontree.hpp>
+#include <raft/cuda_utils.cuh>
 #include "input.cuh"
 #include "kernels.cuh"
 #include "node.cuh"
diff --git a/cpp/src/decisiontree/batched-levelalgo/kernels.cuh b/cpp/src/decisiontree/batched-levelalgo/kernels.cuh
index c3214b2469..7c8051ccdb 100644
--- a/cpp/src/decisiontree/batched-levelalgo/kernels.cuh
+++ b/cpp/src/decisiontree/batched-levelalgo/kernels.cuh
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <common/grid_sync.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "input.cuh"
 #include "metrics.cuh"
 #include "node.cuh"
diff --git a/cpp/src/decisiontree/batched-levelalgo/metrics.cuh b/cpp/src/decisiontree/batched-levelalgo/metrics.cuh
index 043423bc07..1aae3f5b31 100644
--- a/cpp/src/decisiontree/batched-levelalgo/metrics.cuh
+++ b/cpp/src/decisiontree/batched-levelalgo/metrics.cuh
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <common/grid_sync.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "input.cuh"
 #include "node.cuh"
 #include "split.cuh"
diff --git a/cpp/src/decisiontree/batched-levelalgo/split.cuh b/cpp/src/decisiontree/batched-levelalgo/split.cuh
index b81236d01c..e05091ded5 100644
--- a/cpp/src/decisiontree/batched-levelalgo/split.cuh
+++ b/cpp/src/decisiontree/batched-levelalgo/split.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace ML {
 namespace DecisionTree {
diff --git a/cpp/src/decisiontree/decisiontree_impl.cuh b/cpp/src/decisiontree/decisiontree_impl.cuh
index 6b35b54dac..dc7e124cb5 100644
--- a/cpp/src/decisiontree/decisiontree_impl.cuh
+++ b/cpp/src/decisiontree/decisiontree_impl.cuh
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <decisiontree/quantile/quantile.h>
+#include <raft/cudart_utils.h>
 #include <common/iota.cuh>
 #include <cuml/common/logger.hpp>
 #include <iomanip>
diff --git a/cpp/src/decisiontree/levelalgo/common_helper.cuh b/cpp/src/decisiontree/levelalgo/common_helper.cuh
index 3fb21965f1..5a028817eb 100644
--- a/cpp/src/decisiontree/levelalgo/common_helper.cuh
+++ b/cpp/src/decisiontree/levelalgo/common_helper.cuh
@@ -16,10 +16,10 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/tree/flatnode.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/logger.hpp>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include <stats/minmax.cuh>
 #include "common_kernel.cuh"
 
diff --git a/cpp/src/decisiontree/levelalgo/common_kernel.cuh b/cpp/src/decisiontree/levelalgo/common_kernel.cuh
index 8409a9f5c5..20b1abeda6 100644
--- a/cpp/src/decisiontree/levelalgo/common_kernel.cuh
+++ b/cpp/src/decisiontree/levelalgo/common_kernel.cuh
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #pragma once
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #define LEAF 0xFFFFFFFF
 #define PUSHRIGHT 0x00000001
 #include <stats/minmax.cuh>
diff --git a/cpp/src/decisiontree/levelalgo/levelfunc_classifier.cuh b/cpp/src/decisiontree/levelalgo/levelfunc_classifier.cuh
index b8f0d2a72b..fc65b603f0 100644
--- a/cpp/src/decisiontree/levelalgo/levelfunc_classifier.cuh
+++ b/cpp/src/decisiontree/levelalgo/levelfunc_classifier.cuh
@@ -15,8 +15,8 @@
  */
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/tree/flatnode.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/logger.hpp>
 #include <cuml/tree/decisiontree.hpp>
 #include <iostream>
diff --git a/cpp/src/decisiontree/levelalgo/levelfunc_regressor.cuh b/cpp/src/decisiontree/levelalgo/levelfunc_regressor.cuh
index f3a2ba6142..0df203fdfb 100644
--- a/cpp/src/decisiontree/levelalgo/levelfunc_regressor.cuh
+++ b/cpp/src/decisiontree/levelalgo/levelfunc_regressor.cuh
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 #pragma once
-#include <common/cudart_utils.h>
 #include <cuml/tree/flatnode.h>
+#include <raft/cudart_utils.h>
 #include <cuml/tree/decisiontree.hpp>
 #include <iostream>
 #include <numeric>
diff --git a/cpp/src/decisiontree/levelalgo/levelhelper_classifier.cuh b/cpp/src/decisiontree/levelalgo/levelhelper_classifier.cuh
index 8520e249e0..51cf5b7d10 100644
--- a/cpp/src/decisiontree/levelalgo/levelhelper_classifier.cuh
+++ b/cpp/src/decisiontree/levelalgo/levelhelper_classifier.cuh
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "levelkernel_classifier.cuh"
 
 namespace ML {
diff --git a/cpp/src/decisiontree/levelalgo/levelhelper_regressor.cuh b/cpp/src/decisiontree/levelalgo/levelhelper_regressor.cuh
index 0088e1fa15..48c424ba6a 100644
--- a/cpp/src/decisiontree/levelalgo/levelhelper_regressor.cuh
+++ b/cpp/src/decisiontree/levelalgo/levelhelper_regressor.cuh
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "levelkernel_regressor.cuh"
 
 namespace ML {
diff --git a/cpp/src/decisiontree/levelalgo/metric.cuh b/cpp/src/decisiontree/levelalgo/metric.cuh
index 1b8f2e657e..0f533decf7 100644
--- a/cpp/src/decisiontree/levelalgo/metric.cuh
+++ b/cpp/src/decisiontree/levelalgo/metric.cuh
@@ -15,7 +15,7 @@
  */
 
 #pragma once
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "metric_def.cuh"
 
 namespace ML {
diff --git a/cpp/src/decisiontree/levelalgo/metric_def.cuh b/cpp/src/decisiontree/levelalgo/metric_def.cuh
index 8da38d4c31..90a264c6a5 100644
--- a/cpp/src/decisiontree/levelalgo/metric_def.cuh
+++ b/cpp/src/decisiontree/levelalgo/metric_def.cuh
@@ -15,9 +15,9 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
 #include <math.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 #include "../memory.h"
 
diff --git a/cpp/src/decisiontree/memory.h b/cpp/src/decisiontree/memory.h
index e11ad756e5..8964937c2d 100644
--- a/cpp/src/decisiontree/memory.h
+++ b/cpp/src/decisiontree/memory.h
@@ -15,8 +15,8 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
 #include <cuml/tree/flatnode.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/host_buffer.hpp>
diff --git a/cpp/src/decisiontree/quantile/quantile.cuh b/cpp/src/decisiontree/quantile/quantile.cuh
index 409d6eb73b..cf3a61d2ec 100644
--- a/cpp/src/decisiontree/quantile/quantile.cuh
+++ b/cpp/src/decisiontree/quantile/quantile.cuh
@@ -15,7 +15,7 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <cub/cub.cuh>
 #include "quantile.h"
 
diff --git a/cpp/src/fil/common.cuh b/cpp/src/fil/common.cuh
index 83011345e8..11e49e38bc 100644
--- a/cpp/src/fil/common.cuh
+++ b/cpp/src/fil/common.cuh
@@ -23,7 +23,7 @@
 #include <stdexcept>
 #include <string>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <cuml/fil/fil.h>
 
diff --git a/cpp/src/fil/fil.cu b/cpp/src/fil/fil.cu
index 4265f7baa9..6a43bb1f1c 100644
--- a/cpp/src/fil/fil.cu
+++ b/cpp/src/fil/fil.cu
@@ -27,8 +27,8 @@
 #include <stack>
 #include <utility>
 
-#include <common/cudart_utils.h>
 #include <cuml/fil/fil.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/cuml_allocator.hpp>
 #include "common.cuh"
 
diff --git a/cpp/src/glm/ols.cuh b/cpp/src/glm/ols.cuh
index 74ab1c242e..b3812a60a0 100644
--- a/cpp/src/glm/ols.cuh
+++ b/cpp/src/glm/ols.cuh
@@ -16,19 +16,19 @@
 
 #pragma once
 
-#include <linalg/gemv.h>
+#include <raft/linalg/gemv.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <linalg/add.cuh>
 #include <linalg/lstsq.cuh>
-#include <linalg/norm.cuh>
-#include <linalg/subtract.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
-#include <stats/stddev.cuh>
-#include <stats/sum.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
+#include <raft/stats/stddev.cuh>
+#include <raft/stats/sum.cuh>
 #include "preprocess.cuh"
 
 namespace ML {
diff --git a/cpp/src/glm/ols_mg.cu b/cpp/src/glm/ols_mg.cu
index 328aa96175..ef90e88351 100644
--- a/cpp/src/glm/ols_mg.cu
+++ b/cpp/src/glm/ols_mg.cu
@@ -16,17 +16,17 @@
 
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/linear_model/ols_mg.hpp>
 #include <cuml/linear_model/preprocess_mg.hpp>
-#include <linalg/add.cuh>
-#include <linalg/gemm.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
 #include <opg/linalg/lstsq.hpp>
 #include <opg/stats/mean.hpp>
 #include <raft/comms/comms.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 
 using namespace MLCommon;
 
@@ -66,8 +66,8 @@ void fit_impl(raft::handle_t &handle,
   if (algo == 0 || input_desc.N == 1) {
     ASSERT(false, "olsFit: no algorithm with this id has been implemented");
   } else if (algo == 1) {
-    LinAlg::opg::lstsqEig(input_data, input_desc, labels, coef, comm, allocator,
-                          streams, n_streams, cublas_handle, cusolver_handle);
+    LinAlg::opg::lstsqEig(handle, input_data, input_desc, labels, coef, streams,
+                          n_streams);
   } else {
     ASSERT(false, "olsFit: no algorithm with this id has been implemented");
   }
diff --git a/cpp/src/glm/preprocess.cuh b/cpp/src/glm/preprocess.cuh
index d053e7d922..781f5768f9 100644
--- a/cpp/src/glm/preprocess.cuh
+++ b/cpp/src/glm/preprocess.cuh
@@ -16,16 +16,16 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <linalg/gemm.cuh>
-#include <linalg/norm.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
-#include <stats/stddev.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
+#include <raft/stats/stddev.cuh>
 
 namespace ML {
 namespace GLM {
diff --git a/cpp/src/glm/preprocess_mg.cu b/cpp/src/glm/preprocess_mg.cu
index ada30931c0..b01783b5a1 100644
--- a/cpp/src/glm/preprocess_mg.cu
+++ b/cpp/src/glm/preprocess_mg.cu
@@ -14,20 +14,20 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/linear_model/preprocess_mg.hpp>
-#include <linalg/gemm.cuh>
-#include <linalg/subtract.cuh>
-#include <matrix/math.cuh>
 #include <opg/linalg/norm.hpp>
 #include <opg/matrix/math.hpp>
 #include <opg/stats/mean.hpp>
 #include <opg/stats/mean_center.hpp>
 #include <raft/comms/comms.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/matrix/math.cuh>
 
 using namespace MLCommon;
 
@@ -50,8 +50,8 @@ void preProcessData_impl(raft::handle_t &handle,
 
   if (fit_intercept) {
     Matrix::Data<T> mu_input_data{mu_input, size_t(input_desc.N)};
-    Stats::opg::mean(mu_input_data, input_data, input_desc, comm, allocator,
-                     streams, n_streams, cublas_handle);
+    Stats::opg::mean(handle, mu_input_data, input_data, input_desc, streams,
+                     n_streams);
     Stats::opg::mean_center(input_data, input_desc, mu_input_data, comm,
                             streams, n_streams);
 
@@ -59,15 +59,15 @@ void preProcessData_impl(raft::handle_t &handle,
     labels_desc.N = size_t(1);
 
     Matrix::Data<T> mu_labels_data{mu_labels, size_t(1)};
-    Stats::opg::mean(mu_labels_data, labels, labels_desc, comm, allocator,
-                     streams, n_streams, cublas_handle);
+    Stats::opg::mean(handle, mu_labels_data, labels, labels_desc, streams,
+                     n_streams);
     Stats::opg::mean_center(labels, labels_desc, mu_labels_data, comm, streams,
                             n_streams);
 
     if (normalize) {
       Matrix::Data<T> norm2_input_data{norm2_input, size_t(input_desc.N)};
-      LinAlg::opg::colNorm2(norm2_input_data, input_data, input_desc, comm,
-                            allocator, streams, n_streams, cublas_handle);
+      LinAlg::opg::colNorm2(handle, norm2_input_data, input_data, input_desc,
+                            streams, n_streams);
 
       Matrix::opg::matrixVectorBinaryDivSkipZero(
         input_data, input_desc, norm2_input_data, false, true, true, comm,
diff --git a/cpp/src/glm/qn/glm_base.cuh b/cpp/src/glm/qn/glm_base.cuh
index 37292fcf13..1dcfc9b417 100644
--- a/cpp/src/glm/qn/glm_base.cuh
+++ b/cpp/src/glm/qn/glm_base.cuh
@@ -16,14 +16,14 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <stats/mean.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/stats/mean.cuh>
 #include <vector>
 #include "simple_mat.cuh"
 
diff --git a/cpp/src/glm/qn/glm_linear.cuh b/cpp/src/glm/qn/glm_linear.cuh
index 56598291ac..c94da29c88 100644
--- a/cpp/src/glm/qn/glm_linear.cuh
+++ b/cpp/src/glm/qn/glm_linear.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
 #include "glm_base.cuh"
 #include "simple_mat.cuh"
 
diff --git a/cpp/src/glm/qn/glm_logistic.cuh b/cpp/src/glm/qn/glm_logistic.cuh
index 4e865d06ff..3daf7f5693 100644
--- a/cpp/src/glm/qn/glm_logistic.cuh
+++ b/cpp/src/glm/qn/glm_logistic.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
 #include "glm_base.cuh"
 #include "simple_mat.cuh"
 
diff --git a/cpp/src/glm/qn/glm_regularizer.cuh b/cpp/src/glm/qn/glm_regularizer.cuh
index 2360678412..b3644adbc9 100644
--- a/cpp/src/glm/qn/glm_regularizer.cuh
+++ b/cpp/src/glm/qn/glm_regularizer.cuh
@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <stats/mean.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/stats/mean.cuh>
 #include "simple_mat.cuh"
 
 namespace ML {
diff --git a/cpp/src/glm/qn/glm_softmax.cuh b/cpp/src/glm/qn/glm_softmax.cuh
index abb0941f4f..468736a7fe 100644
--- a/cpp/src/glm/qn/glm_softmax.cuh
+++ b/cpp/src/glm/qn/glm_softmax.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
 #include "glm_base.cuh"
 #include "simple_mat.cuh"
 
diff --git a/cpp/src/glm/qn/qn.cuh b/cpp/src/glm/qn/qn.cuh
index 3a00903c91..741e3a06d6 100644
--- a/cpp/src/glm/qn/qn.cuh
+++ b/cpp/src/glm/qn/qn.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 #include <common/device_buffer.hpp>
-#include <matrix/math.cuh>
+#include <raft/matrix/math.cuh>
 #include "glm_base.cuh"
 #include "glm_linear.cuh"
 #include "glm_logistic.cuh"
diff --git a/cpp/src/glm/qn/qn_solvers.cuh b/cpp/src/glm/qn/qn_solvers.cuh
index 9f2772b25e..651577077a 100644
--- a/cpp/src/glm/qn/qn_solvers.cuh
+++ b/cpp/src/glm/qn/qn_solvers.cuh
@@ -40,8 +40,8 @@
  *
  */
 
-#include <cuda_utils.cuh>
 #include <cuml/common/logger.hpp>
+#include <raft/cuda_utils.cuh>
 #include "qn_linesearch.cuh"
 #include "qn_util.cuh"
 #include "simple_mat.cuh"
diff --git a/cpp/src/glm/qn/qn_util.cuh b/cpp/src/glm/qn/qn_util.cuh
index a042732d6d..4546ef736e 100644
--- a/cpp/src/glm/qn/qn_util.cuh
+++ b/cpp/src/glm/qn/qn_util.cuh
@@ -15,9 +15,9 @@
  */
 
 #pragma once
-#include <cuda_utils.cuh>
 #include <cuml/common/logger.hpp>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace GLM {
diff --git a/cpp/src/glm/qn/simple_mat.cuh b/cpp/src/glm/qn/simple_mat.cuh
index e796b18b27..3ab51f63f5 100644
--- a/cpp/src/glm/qn/simple_mat.cuh
+++ b/cpp/src/glm/qn/simple_mat.cuh
@@ -18,16 +18,16 @@
 #include <iostream>
 #include <vector>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/norm.cuh>
 #include <linalg/ternary_op.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace ML {
 
diff --git a/cpp/src/glm/ridge.cuh b/cpp/src/glm/ridge.cuh
index f9575e7e3c..c44ba6d5b3 100644
--- a/cpp/src/glm/ridge.cuh
+++ b/cpp/src/glm/ridge.cuh
@@ -16,19 +16,19 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
-#include <linalg/add.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/norm.cuh>
-#include <linalg/subtract.cuh>
-#include <linalg/svd.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
-#include <stats/stddev.cuh>
-#include <stats/sum.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/linalg/svd.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
+#include <raft/stats/stddev.cuh>
+#include <raft/stats/sum.cuh>
 #include "preprocess.cuh"
 
 namespace ML {
diff --git a/cpp/src/glm/ridge_mg.cu b/cpp/src/glm/ridge_mg.cu
index d31bc8d4fe..f8a30b7359 100644
--- a/cpp/src/glm/ridge_mg.cu
+++ b/cpp/src/glm/ridge_mg.cu
@@ -14,21 +14,21 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/linear_model/preprocess_mg.hpp>
 #include <cuml/linear_model/ridge_mg.hpp>
-#include <linalg/add.cuh>
-#include <linalg/gemm.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
 #include <opg/linalg/mv_aTb.hpp>
 #include <opg/linalg/svd.hpp>
 #include <opg/stats/mean.hpp>
 #include <raft/comms/comms.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 
 using namespace MLCommon;
 
@@ -71,8 +71,7 @@ void ridgeSolve(const raft::handle_t &handle, T *S, T *V,
   Matrix::Data<T> S_nnz_data;
   S_nnz_data.totalSize = UDesc.N;
   S_nnz_data.ptr = S_nnz;
-  LinAlg::opg::mv_aTb(S_nnz_data, U, UDesc, b, comm, allocator, streams,
-                      n_streams, cublasH);
+  LinAlg::opg::mv_aTb(handle, S_nnz_data, U, UDesc, b, streams, n_streams);
 
   raft::linalg::gemm(handle, V, UDesc.N, UDesc.N, S_nnz, w, UDesc.N, 1,
                      CUBLAS_OP_N, CUBLAS_OP_N, alp, beta, streams[0]);
@@ -121,8 +120,8 @@ void ridgeEig(raft::handle_t &handle, const std::vector<Matrix::Data<T> *> &A,
     U.push_back(&(U_temp[i]));
   }
 
-  LinAlg::opg::svdEig(A, ADesc, U, S.data(), V.data(), comm, allocator, streams,
-                      n_streams, cublas_handle, cusolver_handle);
+  LinAlg::opg::svdEig(handle, A, ADesc, U, S.data(), V.data(), streams,
+                      n_streams);
 
   ridgeSolve(handle, S.data(), V.data(), U, ADesc, b, alpha, n_alpha, coef,
              streams, n_streams, verbose);
diff --git a/cpp/src/holtwinters/internal/hw_decompose.cuh b/cpp/src/holtwinters/internal/hw_decompose.cuh
index 7e5ba69053..2cbb54baac 100644
--- a/cpp/src/holtwinters/internal/hw_decompose.cuh
+++ b/cpp/src/holtwinters/internal/hw_decompose.cuh
@@ -15,7 +15,7 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "hw_utils.cuh"
 
 // optimize, maybe im2col ?
diff --git a/cpp/src/holtwinters/internal/hw_eval.cuh b/cpp/src/holtwinters/internal/hw_eval.cuh
index c696c95c4d..dbdac20cb9 100644
--- a/cpp/src/holtwinters/internal/hw_eval.cuh
+++ b/cpp/src/holtwinters/internal/hw_eval.cuh
@@ -15,7 +15,7 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "hw_utils.cuh"
 
 template <typename Dtype>
diff --git a/cpp/src/holtwinters/internal/hw_optim.cuh b/cpp/src/holtwinters/internal/hw_optim.cuh
index 0c6475907d..733a64b26e 100644
--- a/cpp/src/holtwinters/internal/hw_optim.cuh
+++ b/cpp/src/holtwinters/internal/hw_optim.cuh
@@ -15,7 +15,7 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "hw_eval.cuh"
 #include "hw_utils.cuh"
 
diff --git a/cpp/src/holtwinters/internal/hw_utils.cuh b/cpp/src/holtwinters/internal/hw_utils.cuh
index 3cbb41791b..a163cfb7a6 100644
--- a/cpp/src/holtwinters/internal/hw_utils.cuh
+++ b/cpp/src/holtwinters/internal/hw_utils.cuh
@@ -15,16 +15,16 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
 #include <cuda_runtime.h>
 #include <cuml/tsa/holtwinters_params.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
-#include <linalg/eltwise.cuh>
+#include <raft/linalg/eltwise.cuh>
 #include <vector>
 
 #define IDX(n, m, N) (n + (m) * (N))
diff --git a/cpp/src/holtwinters/runner.cuh b/cpp/src/holtwinters/runner.cuh
index f037306db4..bf825a3f16 100644
--- a/cpp/src/holtwinters/runner.cuh
+++ b/cpp/src/holtwinters/runner.cuh
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/tsa/holtwinters_params.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include "internal/hw_decompose.cuh"
 #include "internal/hw_eval.cuh"
 #include "internal/hw_forecast.cuh"
diff --git a/cpp/src/kmeans/common.cuh b/cpp/src/kmeans/common.cuh
index 775fff7ef0..8eb8279c7b 100644
--- a/cpp/src/kmeans/common.cuh
+++ b/cpp/src/kmeans/common.cuh
@@ -17,15 +17,15 @@
 
 #include <distance/distance.cuh>
 #include <distance/fused_l2_nn.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/mean_squared_error.cuh>
-#include <linalg/reduce.cuh>
 #include <linalg/reduce_cols_by_key.cuh>
 #include <linalg/reduce_rows_by_key.cuh>
 #include <matrix/gather.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/mean_squared_error.cuh>
+#include <raft/linalg/reduce.cuh>
+#include <raft/random/rng.cuh>
 #include <random/permute.cuh>
-#include <random/rng.cuh>
 #include <random>
 
 #include <thrust/equal.h>
@@ -48,7 +48,7 @@
 
 #include <cuml/cluster/kmeans_mg.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <fstream>
 
 namespace ML {
diff --git a/cpp/src/kmeans/kmeans_mg_impl.cuh b/cpp/src/kmeans/kmeans_mg_impl.cuh
index 0892f6e848..b45a7f14ad 100644
--- a/cpp/src/kmeans/kmeans_mg_impl.cuh
+++ b/cpp/src/kmeans/kmeans_mg_impl.cuh
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "common.cuh"
 #include "sg_impl.cuh"
 
diff --git a/cpp/src/kmeans/sg_impl.cuh b/cpp/src/kmeans/sg_impl.cuh
index c0009b59e4..89d79e8413 100644
--- a/cpp/src/kmeans/sg_impl.cuh
+++ b/cpp/src/kmeans/sg_impl.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "common.cuh"
 
 namespace ML {
diff --git a/cpp/src/knn/knn.cu b/cpp/src/knn/knn.cu
index 367a4a8d00..16b081cbc9 100644
--- a/cpp/src/knn/knn.cu
+++ b/cpp/src/knn/knn.cu
@@ -25,7 +25,7 @@
 #include <selection/knn.cuh>
 
 #include <cuda_runtime.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <sstream>
 #include <vector>
diff --git a/cpp/src/knn/knn_mg.cu b/cpp/src/knn/knn_mg.cu
index f27663bd28..fa106605ee 100644
--- a/cpp/src/knn/knn_mg.cu
+++ b/cpp/src/knn/knn_mg.cu
@@ -25,8 +25,8 @@
 
 #include <set>
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace KNN {
diff --git a/cpp/src/knn/knn_opg_common.cu b/cpp/src/knn/knn_opg_common.cu
index cae7fc190e..e3726aa981 100644
--- a/cpp/src/knn/knn_opg_common.cu
+++ b/cpp/src/knn/knn_opg_common.cu
@@ -59,8 +59,8 @@
 
 #include <set>
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace KNN {
diff --git a/cpp/src/knn/knn_opg_common.cuh b/cpp/src/knn/knn_opg_common.cuh
index ffa916c5d8..c3356f14cb 100644
--- a/cpp/src/knn/knn_opg_common.cuh
+++ b/cpp/src/knn/knn_opg_common.cuh
@@ -60,7 +60,7 @@
 
 #include <set>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace KNN {
diff --git a/cpp/src/metrics/metrics.cu b/cpp/src/metrics/metrics.cu
index 191c4c03a8..4c80b6d5d3 100644
--- a/cpp/src/metrics/metrics.cu
+++ b/cpp/src/metrics/metrics.cu
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <cuda_utils.cuh>
 #include <cuml/metrics/metrics.hpp>
 #include <metrics/adjustedRandIndex.cuh>
 #include <metrics/klDivergence.cuh>
diff --git a/cpp/src/metrics/trustworthiness.cu b/cpp/src/metrics/trustworthiness.cu
index 8fdd5aac09..8449adf824 100644
--- a/cpp/src/metrics/trustworthiness.cu
+++ b/cpp/src/metrics/trustworthiness.cu
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
 #include <distance/distance.cuh>
 #include <metrics/scores.cuh>
+#include <raft/handle.hpp>
 
 namespace ML {
 namespace Metrics {
diff --git a/cpp/src/ml_cuda_utils.h b/cpp/src/ml_cuda_utils.h
index b86ba4773c..39db0346d0 100644
--- a/cpp/src/ml_cuda_utils.h
+++ b/cpp/src/ml_cuda_utils.h
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuda_runtime.h>
+#include <raft/cudart_utils.h>
 
 namespace ML {
 
diff --git a/cpp/src/ml_mg_utils.cuh b/cpp/src/ml_mg_utils.cuh
index 75608f7830..5fb1ace2d7 100644
--- a/cpp/src/ml_mg_utils.cuh
+++ b/cpp/src/ml_mg_utils.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 #include <cuda_runtime.h>
 
diff --git a/cpp/src/pca/pca.cuh b/cpp/src/pca/pca.cuh
index 969bd807d8..4d78272fdc 100644
--- a/cpp/src/pca/pca.cuh
+++ b/cpp/src/pca/pca.cuh
@@ -16,20 +16,20 @@
 
 #pragma once
 
-#include <linalg/transpose.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/cuml.hpp>
 #include <cuml/decomposition/params.hpp>
-#include <linalg/eig.cuh>
-#include <linalg/eltwise.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/eig.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
 #include <stats/cov.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
 #include <tsvd/tsvd.cuh>
 
 namespace ML {
diff --git a/cpp/src/pca/pca_mg.cu b/cpp/src/pca/pca_mg.cu
index 4d346f2a7d..db311dd409 100644
--- a/cpp/src/pca/pca_mg.cu
+++ b/cpp/src/pca/pca_mg.cu
@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/decomposition/pca.hpp>
 #include <cuml/decomposition/pca_mg.hpp>
 #include <cuml/decomposition/sign_flip_mg.hpp>
-#include <matrix/math.cuh>
 #include <opg/linalg/qr_based_svd.hpp>
 #include <opg/matrix/matrix_utils.hpp>
 #include <opg/stats/cov.hpp>
 #include <opg/stats/mean.hpp>
 #include <opg/stats/mean_center.hpp>
 #include <raft/comms/comms.hpp>
-#include <stats/mean_center.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/stats/mean_center.cuh>
 #include "pca.cuh"
 
 using namespace MLCommon;
@@ -52,15 +52,14 @@ void fit_impl(raft::handle_t &handle,
 
   Matrix::Data<T> mu_data{mu, size_t(prms.n_cols)};
 
-  Stats::opg::mean(mu_data, input_data, input_desc, comm, allocator, streams,
-                   n_streams, handle.get_cublas_handle());
+  Stats::opg::mean(handle, mu_data, input_data, input_desc, streams, n_streams);
 
   device_buffer<T> cov_data(allocator, streams[0], prms.n_cols * prms.n_cols);
   size_t cov_data_size = cov_data.size();
   Matrix::Data<T> cov{cov_data.data(), cov_data_size};
 
-  Stats::opg::cov(cov, input_data, input_desc, mu_data, true, comm, allocator,
-                  streams, n_streams, cublas_handle);
+  Stats::opg::cov(handle, cov, input_data, input_desc, mu_data, true, streams,
+                  n_streams);
 
   ML::truncCompExpVars<T, mg_solver>(handle, cov.ptr, components, explained_var,
                                      explained_var_ratio, prms, streams[0]);
@@ -119,8 +118,8 @@ void fit_impl(raft::handle_t &handle,
 
     // Center the data
     Matrix::Data<T> mu_data{mu, size_t(prms.n_cols)};
-    Stats::opg::mean(mu_data, input_data, input_desc, comm, allocator, streams,
-                     n_streams, handle.get_cublas_handle());
+    Stats::opg::mean(handle, mu_data, input_data, input_desc, streams,
+                     n_streams);
     Stats::opg::mean_center(input_data, input_desc, mu_data, comm, streams,
                             n_streams);
     for (int i = 0; i < n_streams; i++) {
diff --git a/cpp/src/pca/sign_flip_mg.cu b/cpp/src/pca/sign_flip_mg.cu
index b1c8973a23..9050975cf2 100644
--- a/cpp/src/pca/sign_flip_mg.cu
+++ b/cpp/src/pca/sign_flip_mg.cu
@@ -19,12 +19,12 @@
 #include <common/allocatorAdapter.hpp>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/decomposition/sign_flip_mg.hpp>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
 #include <raft/comms/comms.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 
 using namespace MLCommon;
 
diff --git a/cpp/src/random_projection/rproj.cuh b/cpp/src/random_projection/rproj.cuh
index 2080a9dc79..37190cf7ba 100644
--- a/cpp/src/random_projection/rproj.cuh
+++ b/cpp/src/random_projection/rproj.cuh
@@ -20,12 +20,12 @@
 #include <unordered_set>
 #include <vector>
 
-#include <common/cudart_utils.h>
 #include <cuml/random_projection/rproj_c.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/sparse/cusparse_wrappers.h>
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "rproj_utils.cuh"
 
 namespace ML {
diff --git a/cpp/src/random_projection/rproj_utils.cuh b/cpp/src/random_projection/rproj_utils.cuh
index fd977f917c..38649acc39 100644
--- a/cpp/src/random_projection/rproj_utils.cuh
+++ b/cpp/src/random_projection/rproj_utils.cuh
@@ -16,12 +16,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/random_projection/rproj_c.h>
+#include <raft/cudart_utils.h>
 #include <sys/time.h>
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 
 const int TPB_X = 256;
 
diff --git a/cpp/src/randomforest/randomforest_impl.cuh b/cpp/src/randomforest/randomforest_impl.cuh
index 8500aed08e..ebd5e55864 100644
--- a/cpp/src/randomforest/randomforest_impl.cuh
+++ b/cpp/src/randomforest/randomforest_impl.cuh
@@ -17,13 +17,13 @@
 #ifndef _OPENMP
 #define omp_get_thread_num() 0
 #endif
-#include <common/cudart_utils.h>
 #include <decisiontree/memory.h>
 #include <decisiontree/quantile/quantile.h>
+#include <raft/cudart_utils.h>
 #include <cuml/common/logger.hpp>
 #include <metrics/scores.cuh>
+#include <raft/random/rng.cuh>
 #include <random/permute.cuh>
-#include <random/rng.cuh>
 #include "randomforest_impl.h"
 
 namespace ML {
diff --git a/cpp/src/solver/cd.cuh b/cpp/src/solver/cd.cuh
index 66ce437626..978052fff7 100644
--- a/cpp/src/solver/cd.cuh
+++ b/cpp/src/solver/cd.cuh
@@ -16,24 +16,24 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/solvers/params.hpp>
 #include <functions/linearReg.cuh>
 #include <functions/penalty.cuh>
 #include <functions/softThres.cuh>
 #include <glm/preprocess.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/multiply.cuh>
-#include <linalg/subtract.cuh>
-#include <linalg/unary_op.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/multiply.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "shuffle.h"
 
 namespace ML {
diff --git a/cpp/src/solver/cd_mg.cu b/cpp/src/solver/cd_mg.cu
index c209de9dc9..1b48b958ca 100644
--- a/cpp/src/solver/cd_mg.cu
+++ b/cpp/src/solver/cd_mg.cu
@@ -14,24 +14,24 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/linear_model/preprocess_mg.hpp>
 #include <cuml/solvers/cd_mg.hpp>
 #include <functions/softThres.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/multiply.cuh>
-#include <linalg/subtract.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
 #include <opg/linalg/mv_aTb.hpp>
 #include <opg/linalg/norm.hpp>
 #include <raft/comms/comms.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/multiply.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "shuffle.h"
 
 using namespace MLCommon;
@@ -108,8 +108,8 @@ void fit_impl(raft::handle_t &handle,
                            streams[0]);
   } else {
     Matrix::Data<T> squared_data{squared.data(), size_t(input_desc.N)};
-    LinAlg::opg::colNorm2NoSeq(squared_data, input_data, input_desc, comm,
-                               allocator, streams, n_streams, cublas_handle);
+    LinAlg::opg::colNorm2NoSeq(handle, squared_data, input_data, input_desc,
+                               streams, n_streams);
     raft::linalg::addScalar(squared.data(), squared.data(), l2_alpha,
                             input_desc.N, streams[0]);
   }
@@ -184,9 +184,8 @@ void fit_impl(raft::handle_t &handle,
 
       coef_loc_data.ptr = coef_loc;
       coef_loc_data.totalSize = size_t(1);
-      LinAlg::opg::mv_aTb(coef_loc_data, input_data_temp, input_desc_temp,
-                          residual_temp, comm, allocator, streams, n_streams,
-                          cublas_handle);
+      LinAlg::opg::mv_aTb(handle, coef_loc_data, input_data_temp,
+                          input_desc_temp, residual_temp, streams, n_streams);
 
       if (l1_ratio > T(0.0))
         Functions::softThres(coef_loc, coef_loc, alpha, 1, streams[0]);
diff --git a/cpp/src/solver/sgd.cuh b/cpp/src/solver/sgd.cuh
index e7826ee7b0..530897f3b5 100644
--- a/cpp/src/solver/sgd.cuh
+++ b/cpp/src/solver/sgd.cuh
@@ -16,25 +16,25 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/gemv.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/gemv.h>
 #include <common/cumlHandle.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/solvers/params.hpp>
 #include <functions/hinge.cuh>
 #include <functions/linearReg.cuh>
 #include <functions/logisticReg.cuh>
 #include <glm/preprocess.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/norm.cuh>
-#include <linalg/subtract.cuh>
-#include <linalg/unary_op.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
 #include "learning_rate.h"
 #include "shuffle.h"
 
diff --git a/cpp/src/svm/kernelcache.cuh b/cpp/src/svm/kernelcache.cuh
index 1b25563857..9c5b72924d 100644
--- a/cpp/src/svm/kernelcache.cuh
+++ b/cpp/src/svm/kernelcache.cuh
@@ -16,18 +16,18 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/svm/svm_parameter.h>
 #include <linalg/init.h>
+#include <raft/cudart_utils.h>
 #include <cache/cache.cuh>
 #include <cache/cache_util.cuh>
 #include <common/cumlHandle.hpp>
 #include <common/host_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <linalg/gemm.cuh>
 #include <matrix/grammatrix.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/matrix/matrix.cuh>
 
 namespace ML {
 namespace SVM {
diff --git a/cpp/src/svm/results.cuh b/cpp/src/svm/results.cuh
index b48a939890..2f5776c2f4 100644
--- a/cpp/src/svm/results.cuh
+++ b/cpp/src/svm/results.cuh
@@ -17,23 +17,23 @@
 #pragma once
 
 #include <math.h>
-#include <cuda_utils.cuh>
 #include <iostream>
 #include <limits>
 #include <memory>
+#include <raft/cuda_utils.cuh>
 
-#include <common/cudart_utils.h>
 #include <linalg/init.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/host_buffer.hpp>
 #include <cub/device/device_select.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/add.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/unary_op.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "ws_util.cuh"
 
 namespace ML {
diff --git a/cpp/src/svm/smo_sets.cuh b/cpp/src/svm/smo_sets.cuh
index a128e51cb4..bc1c8ad6ee 100644
--- a/cpp/src/svm/smo_sets.cuh
+++ b/cpp/src/svm/smo_sets.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace SVM {
diff --git a/cpp/src/svm/smoblocksolve.cuh b/cpp/src/svm/smoblocksolve.cuh
index a4498f8154..a876ea0088 100644
--- a/cpp/src/svm/smoblocksolve.cuh
+++ b/cpp/src/svm/smoblocksolve.cuh
@@ -20,7 +20,7 @@
 
 #include <cuml/svm/svm_parameter.h>
 #include <stdlib.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include <selection/kselection.cuh>
 #include "smo_sets.cuh"
 
diff --git a/cpp/src/svm/smosolver.cuh b/cpp/src/svm/smosolver.cuh
index 22d0a10d78..1396650dac 100644
--- a/cpp/src/svm/smosolver.cuh
+++ b/cpp/src/svm/smosolver.cuh
@@ -16,24 +16,24 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <thrust/device_ptr.h>
 #include <thrust/fill.h>
-#include <cuda_utils.cuh>
 #include <iostream>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 #include <string>
 #include <type_traits>
 
 #include <cuml/matrix/kernelparams.h>
-#include <linalg/gemv.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/gemv.h>
 #include <common/cumlHandle.hpp>
 #include <cuml/common/logger.hpp>
-#include <linalg/unary_op.cuh>
 #include <matrix/grammatrix.cuh>
 #include <matrix/kernelfactory.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "kernelcache.cuh"
 #include "smo_sets.cuh"
 #include "smoblocksolve.cuh"
diff --git a/cpp/src/svm/svc.cu b/cpp/src/svm/svc.cu
index dd4ad4dd52..b25327c969 100644
--- a/cpp/src/svm/svc.cu
+++ b/cpp/src/svm/svc.cu
@@ -20,8 +20,8 @@
 #include <common/device_buffer.hpp>
 #include <cuml/svm/svc.hpp>
 #include <label/classlabels.cuh>
-#include <linalg/unary_op.cuh>
 #include <matrix/kernelfactory.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "kernelcache.cuh"
 #include "smosolver.cuh"
 #include "svc_impl.cuh"
diff --git a/cpp/src/svm/svc_impl.cuh b/cpp/src/svm/svc_impl.cuh
index 641d562878..34f708bc24 100644
--- a/cpp/src/svm/svc_impl.cuh
+++ b/cpp/src/svm/svc_impl.cuh
@@ -33,9 +33,9 @@
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <label/classlabels.cuh>
-#include <linalg/unary_op.cuh>
 #include <matrix/kernelfactory.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "kernelcache.cuh"
 #include "smosolver.cuh"
 
diff --git a/cpp/src/svm/svr.cu b/cpp/src/svm/svr.cu
index 57f082d70e..3047e88cf4 100644
--- a/cpp/src/svm/svr.cu
+++ b/cpp/src/svm/svr.cu
@@ -20,8 +20,8 @@
 #include <common/device_buffer.hpp>
 #include <cuml/svm/svc.hpp>
 #include <label/classlabels.cuh>
-#include <linalg/unary_op.cuh>
 #include <matrix/kernelfactory.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "kernelcache.cuh"
 #include "smosolver.cuh"
 #include "svr_impl.cuh"
diff --git a/cpp/src/svm/svr_impl.cuh b/cpp/src/svm/svr_impl.cuh
index 8e1630e064..257e1ce726 100644
--- a/cpp/src/svm/svr_impl.cuh
+++ b/cpp/src/svm/svr_impl.cuh
@@ -32,9 +32,9 @@
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <label/classlabels.cuh>
-#include <linalg/unary_op.cuh>
 #include <matrix/kernelfactory.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "kernelcache.cuh"
 #include "smosolver.cuh"
 #include "svc_impl.cuh"
diff --git a/cpp/src/svm/workingset.cuh b/cpp/src/svm/workingset.cuh
index 74e6443e58..eee4fe6cb8 100644
--- a/cpp/src/svm/workingset.cuh
+++ b/cpp/src/svm/workingset.cuh
@@ -16,18 +16,18 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/svm/svm_parameter.h>
 #include <limits.h>
 #include <linalg/init.h>
+#include <raft/cudart_utils.h>
 #include <thrust/device_ptr.h>
 #include <thrust/iterator/permutation_iterator.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "smo_sets.cuh"
 #include "ws_util.cuh"
 
diff --git a/cpp/src/svm/ws_util.cu b/cpp/src/svm/ws_util.cu
index ab7599078c..43601fe4b7 100644
--- a/cpp/src/svm/ws_util.cu
+++ b/cpp/src/svm/ws_util.cu
@@ -16,7 +16,7 @@
 
 #include <limits.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace SVM {
diff --git a/cpp/src/tsa/auto_arima.cuh b/cpp/src/tsa/auto_arima.cuh
index b9484041bd..918be7d408 100644
--- a/cpp/src/tsa/auto_arima.cuh
+++ b/cpp/src/tsa/auto_arima.cuh
@@ -27,7 +27,7 @@
 #include <thrust/transform.h>
 #include <cub/device/device_scan.cuh>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <common/fast_int_div.cuh>
 #include <cuml/common/cuml_allocator.hpp>
diff --git a/cpp/src/tsne/barnes_hut.cuh b/cpp/src/tsne/barnes_hut.cuh
index 145f33a7e9..267eda2b12 100644
--- a/cpp/src/tsne/barnes_hut.cuh
+++ b/cpp/src/tsne/barnes_hut.cuh
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cuml/common/logger.hpp>
 #include "bh_kernels.cuh"
diff --git a/cpp/src/tsne/bh_kernels.cuh b/cpp/src/tsne/bh_kernels.cuh
index def5312f9f..ef030e7f14 100644
--- a/cpp/src/tsne/bh_kernels.cuh
+++ b/cpp/src/tsne/bh_kernels.cuh
@@ -33,8 +33,8 @@
 #define FACTOR6 2
 #define FACTOR7 1
 
-#include <common/cudart_utils.h>
 #include <float.h>
+#include <raft/cudart_utils.h>
 
 namespace ML {
 namespace TSNE {
diff --git a/cpp/src/tsne/distances.cuh b/cpp/src/tsne/distances.cuh
index 6730392745..922b361de9 100644
--- a/cpp/src/tsne/distances.cuh
+++ b/cpp/src/tsne/distances.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/eltwise.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/eltwise.cuh>
 #include <selection/knn.cuh>
 #include <sparse/coo.cuh>
 
diff --git a/cpp/src/tsne/exact_kernels.cuh b/cpp/src/tsne/exact_kernels.cuh
index 041058e9f5..e88e4f5e7d 100644
--- a/cpp/src/tsne/exact_kernels.cuh
+++ b/cpp/src/tsne/exact_kernels.cuh
@@ -16,10 +16,10 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <float.h>
 #include <math.h>
-#include <linalg/eltwise.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/eltwise.cuh>
 
 #define restrict __restrict__
 
diff --git a/cpp/src/tsne/exact_tsne.cuh b/cpp/src/tsne/exact_tsne.cuh
index c7352edb2f..b4b8b7f826 100644
--- a/cpp/src/tsne/exact_tsne.cuh
+++ b/cpp/src/tsne/exact_tsne.cuh
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cuml/common/logger.hpp>
 #include "exact_kernels.cuh"
diff --git a/cpp/src/tsne/tsne.cu b/cpp/src/tsne/tsne.cu
index 648bcb1ea9..d1e02269c6 100644
--- a/cpp/src/tsne/tsne.cu
+++ b/cpp/src/tsne/tsne.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/tsne.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cuml/common/logger.hpp>
 #include "distances.cuh"
diff --git a/cpp/src/tsne/utils.cuh b/cpp/src/tsne/utils.cuh
index fe4a59194b..07ad934579 100644
--- a/cpp/src/tsne/utils.cuh
+++ b/cpp/src/tsne/utils.cuh
@@ -23,7 +23,7 @@
 
 #include <common/cumlHandle.hpp>
 #include <cuml/common/logger.hpp>
-#include <linalg/norm.cuh>
+#include <raft/linalg/norm.cuh>
 
 #include <cuda_runtime.h>
 #include <cuml/cuml.hpp>
@@ -33,8 +33,8 @@
 #include <thrust/transform.h>
 
 #include <sys/time.h>
-#include <random/rng.cuh>
-#include <stats/sum.cuh>
+#include <raft/random/rng.cuh>
+#include <raft/stats/sum.cuh>
 
 #include <unistd.h>
 #include <chrono>
diff --git a/cpp/src/tsvd/tsvd.cuh b/cpp/src/tsvd/tsvd.cuh
index 61fb159213..866d83dfc7 100644
--- a/cpp/src/tsvd/tsvd.cuh
+++ b/cpp/src/tsvd/tsvd.cuh
@@ -16,26 +16,26 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 #include <thrust/device_vector.h>
 #include <thrust/execution_policy.h>
 #include <common/allocatorAdapter.hpp>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/decomposition/params.hpp>
-#include <linalg/binary_op.cuh>
-#include <linalg/eig.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
 #include <linalg/rsvd.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/stddev.cuh>
-#include <stats/sum.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/eig.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/stddev.cuh>
+#include <raft/stats/sum.cuh>
 
 namespace ML {
 
diff --git a/cpp/src/tsvd/tsvd_mg.cu b/cpp/src/tsvd/tsvd_mg.cu
index ec38672042..59be9ee6e2 100644
--- a/cpp/src/tsvd/tsvd_mg.cu
+++ b/cpp/src/tsvd/tsvd_mg.cu
@@ -14,22 +14,22 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/decomposition/sign_flip_mg.hpp>
 #include <cuml/decomposition/tsvd.hpp>
 #include <cuml/decomposition/tsvd_mg.hpp>
-#include <linalg/eltwise.cuh>
-#include <matrix/math.cuh>
 #include <opg/linalg/mm_aTa.hpp>
 #include <opg/stats/mean.hpp>
 #include <opg/stats/mean_center.hpp>
 #include <opg/stats/stddev.hpp>
 #include <raft/comms/comms.hpp>
-#include <stats/mean_center.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/stats/mean_center.cuh>
 #include "tsvd.cuh"
 
 using namespace MLCommon;
@@ -56,8 +56,7 @@ void fit_impl(raft::handle_t &handle,
   size_t cov_data_size = cov_data.size();
   Matrix::Data<T> cov{cov_data.data(), cov_data_size};
 
-  LinAlg::opg::mm_aTa(cov, input_data, input_desc, comm, allocator, streams,
-                      n_streams, cublas_handle);
+  LinAlg::opg::mm_aTa(handle, cov, input_data, input_desc, streams, n_streams);
 
   device_buffer<T> components_all(allocator, streams[0], len);
   device_buffer<T> explained_var_all(allocator, streams[0], prms.n_cols);
@@ -311,30 +310,25 @@ void fit_transform_impl(raft::handle_t &handle,
                             prms.n_components);
   Matrix::Data<T> mu_trans_data{mu_trans.data(), size_t(prms.n_components)};
 
-  Stats::opg::mean(mu_trans_data, trans_data, trans_desc, handle.get_comms(),
-                   handle.get_device_allocator(), streams, n_streams,
-                   handle.get_cublas_handle());
+  Stats::opg::mean(handle, mu_trans_data, trans_data, trans_desc, streams,
+                   n_streams);
 
   Matrix::Data<T> explained_var_data{explained_var, size_t(prms.n_components)};
 
-  Stats::opg::var(explained_var_data, trans_data, trans_desc, mu_trans_data.ptr,
-                  handle.get_comms(), handle.get_device_allocator(), streams,
-                  n_streams, handle.get_cublas_handle());
+  Stats::opg::var(handle, explained_var_data, trans_data, trans_desc,
+                  mu_trans_data.ptr, streams, n_streams);
 
   device_buffer<T> mu(handle.get_device_allocator(), streams[0], prms.n_rows);
   Matrix::Data<T> mu_data{mu.data(), size_t(prms.n_rows)};
 
-  Stats::opg::mean(mu_data, input_data, input_desc, handle.get_comms(),
-                   handle.get_device_allocator(), streams, n_streams,
-                   handle.get_cublas_handle());
+  Stats::opg::mean(handle, mu_data, input_data, input_desc, streams, n_streams);
 
   device_buffer<T> var_input(handle.get_device_allocator(), streams[0],
                              prms.n_rows);
   Matrix::Data<T> var_input_data{var_input.data(), size_t(prms.n_rows)};
 
-  Stats::opg::var(var_input_data, input_data, input_desc, mu_data.ptr,
-                  handle.get_comms(), handle.get_device_allocator(), streams,
-                  n_streams, handle.get_cublas_handle());
+  Stats::opg::var(handle, var_input_data, input_data, input_desc, mu_data.ptr,
+                  streams, n_streams);
 
   device_buffer<T> total_vars(handle.get_device_allocator(), streams[0], 1);
   raft::stats::sum(total_vars.data(), var_input_data.ptr, 1, prms.n_cols, false,
diff --git a/cpp/src/umap/fuzzy_simpl_set/naive.cuh b/cpp/src/umap/fuzzy_simpl_set/naive.cuh
index 2edbd3302b..8028dc80b6 100644
--- a/cpp/src/umap/fuzzy_simpl_set/naive.cuh
+++ b/cpp/src/umap/fuzzy_simpl_set/naive.cuh
@@ -20,11 +20,11 @@
 #include <cuml/common/logger.hpp>
 #include <cuml/neighbors/knn.hpp>
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
+#include <raft/stats/mean.cuh>
 #include <sparse/coo.cuh>
-#include <stats/mean.cuh>
 
 #include <cuda_runtime.h>
 
diff --git a/cpp/src/umap/init_embed/random_algo.cuh b/cpp/src/umap/init_embed/random_algo.cuh
index 2517f2ec50..b555dda35b 100644
--- a/cpp/src/umap/init_embed/random_algo.cuh
+++ b/cpp/src/umap/init_embed/random_algo.cuh
@@ -15,7 +15,7 @@
  */
 
 #include <cuml/manifold/umapparams.h>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 
 #pragma once
 
diff --git a/cpp/src/umap/init_embed/spectral_algo.cuh b/cpp/src/umap/init_embed/spectral_algo.cuh
index 0ba28e1afd..86adcc1e3e 100644
--- a/cpp/src/umap/init_embed/spectral_algo.cuh
+++ b/cpp/src/umap/init_embed/spectral_algo.cuh
@@ -21,10 +21,10 @@
 
 #include <sparse/coo.cuh>
 
-#include <linalg/add.cuh>
+#include <raft/linalg/add.cuh>
 
-#include <linalg/transpose.h>
-#include <random/rng.cuh>
+#include <raft/linalg/transpose.h>
+#include <raft/random/rng.cuh>
 
 #include <cuml/cluster/spectral.hpp>
 #include <iostream>
diff --git a/cpp/src/umap/knn_graph/algo.cuh b/cpp/src/umap/knn_graph/algo.cuh
index 3c322cddcc..53b74eae8d 100644
--- a/cpp/src/umap/knn_graph/algo.cuh
+++ b/cpp/src/umap/knn_graph/algo.cuh
@@ -16,7 +16,7 @@
 
 #include <cuml/manifold/umapparams.h>
 #include <iostream>
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include <selection/knn.cuh>
 
 #pragma once
diff --git a/cpp/src/umap/optimize.cuh b/cpp/src/umap/optimize.cuh
index 31aaee41ad..6ac130d34d 100644
--- a/cpp/src/umap/optimize.cuh
+++ b/cpp/src/umap/optimize.cuh
@@ -21,15 +21,15 @@
 
 #include <common/device_buffer.hpp>
 
-#include <common/cudart_utils.h>
-#include <linalg/add.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/multiply.cuh>
+#include <raft/cudart_utils.h>
 #include <linalg/power.cuh>
-#include <linalg/unary_op.cuh>
-#include <matrix/math.cuh>
-#include <stats/mean.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/multiply.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/stats/mean.cuh>
 
 #include <cuda_runtime.h>
 
diff --git a/cpp/src/umap/runner.cuh b/cpp/src/umap/runner.cuh
index 4df2ad4036..d9c8f6733a 100644
--- a/cpp/src/umap/runner.cuh
+++ b/cpp/src/umap/runner.cuh
@@ -36,7 +36,7 @@
 #include <sparse/coo.cuh>
 #include <sparse/csr.cuh>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <cuda_runtime.h>
 #include <common/nvtx.hpp>
diff --git a/cpp/src/umap/simpl_set_embed/algo.cuh b/cpp/src/umap/simpl_set_embed/algo.cuh
index b9b5fe9235..120a57bf0e 100644
--- a/cpp/src/umap/simpl_set_embed/algo.cuh
+++ b/cpp/src/umap/simpl_set_embed/algo.cuh
@@ -16,18 +16,18 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/umapparams.h>
 #include <curand.h>
 #include <internals/internals.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <thrust/device_ptr.h>
 #include <thrust/extrema.h>
 #include <thrust/system/cuda/execution_policy.h>
 #include <common/fast_int_div.cuh>
 #include <cstdlib>
 #include <cuml/common/logger.hpp>
-#include <random/rng_impl.cuh>
+#include <raft/random/rng_impl.cuh>
 #include <sparse/coo.cuh>
 #include <string>
 #include "optimize_batch_kernel.cuh"
diff --git a/cpp/src/umap/simpl_set_embed/optimize_batch_kernel.cuh b/cpp/src/umap/simpl_set_embed/optimize_batch_kernel.cuh
index 24bd0c870f..eb250cbf68 100644
--- a/cpp/src/umap/simpl_set_embed/optimize_batch_kernel.cuh
+++ b/cpp/src/umap/simpl_set_embed/optimize_batch_kernel.cuh
@@ -16,10 +16,10 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/umapparams.h>
+#include <raft/cudart_utils.h>
 #include <common/fast_int_div.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace UMAPAlgo {
 namespace SimplSetEmbed {
diff --git a/cpp/src/umap/supervised.cuh b/cpp/src/umap/supervised.cuh
index 90ff5f9200..2e455ba528 100644
--- a/cpp/src/umap/supervised.cuh
+++ b/cpp/src/umap/supervised.cuh
@@ -21,7 +21,7 @@
 #include <cuml/neighbors/knn.hpp>
 #include "optimize.cuh"
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include "fuzzy_simpl_set/runner.cuh"
 #include "init_embed/runner.cuh"
 #include "knn_graph/runner.cuh"
@@ -37,7 +37,7 @@
 #include <sparse/coo.cuh>
 #include <sparse/csr.cuh>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <cuda_runtime.h>
 
diff --git a/cpp/src_prims/cache/cache.cuh b/cpp/src_prims/cache/cache.cuh
index 17f49f836e..e3a25b53a4 100644
--- a/cpp/src_prims/cache/cache.cuh
+++ b/cpp/src_prims/cache/cache.cuh
@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/logger.hpp>
+#include <raft/cuda_utils.cuh>
 #include "cache_util.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/cache/cache_util.cuh b/cpp/src_prims/cache/cache_util.cuh
index 7de22a2d2f..3cc5b27a2f 100644
--- a/cpp/src_prims/cache/cache_util.cuh
+++ b/cpp/src_prims/cache/cache_util.cuh
@@ -18,7 +18,7 @@
 
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include <selection/kselection.cuh>
 
 namespace MLCommon {
diff --git a/cpp/src_prims/common/cub_wrappers.cuh b/cpp/src_prims/common/cub_wrappers.cuh
deleted file mode 100644
index 8d5b29f700..0000000000
--- a/cpp/src_prims/common/cub_wrappers.cuh
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2019, 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 <cub/cub.cuh>
-#include <raft/mr/device/buffer.hpp>
-
-namespace raft {
-
-/**
-     * @brief Convenience wrapper over cub's SortPairs method
-     * @tparam KeyT key type
-     * @tparam ValueT value type
-     * @param workspace workspace buffer which will get resized if not enough space
-     * @param inKeys input keys array
-     * @param outKeys output keys array
-     * @param inVals input values array
-     * @param outVals output values array
-     * @param len array length
-     * @param stream cuda stream
-     */
-template <typename KeyT, typename ValueT>
-void sortPairs(raft::mr::device::buffer<char> &workspace, const KeyT *inKeys,
-               KeyT *outKeys, const ValueT *inVals, ValueT *outVals, int len,
-               cudaStream_t stream) {
-  size_t worksize;
-  cub::DeviceRadixSort::SortPairs(nullptr, worksize, inKeys, outKeys, inVals,
-                                  outVals, len, 0, sizeof(KeyT) * 8, stream);
-  workspace.resize(worksize, stream);
-  cub::DeviceRadixSort::SortPairs(workspace.data(), worksize, inKeys, outKeys,
-                                  inVals, outVals, len, 0, sizeof(KeyT) * 8,
-                                  stream);
-}
-
-}  // namespace raft
diff --git a/cpp/src_prims/common/cudart_utils.h b/cpp/src_prims/common/cudart_utils.h
deleted file mode 100644
index 005413d025..0000000000
--- a/cpp/src_prims/common/cudart_utils.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2019, 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 <chrono>
-#include <cuml/common/utils.hpp>
-#include <iomanip>
-#include <iostream>
-
-namespace raft {
-
-/** helper method to get max usable shared mem per block parameter */
-inline int getSharedMemPerBlock() {
-  int devId;
-  CUDA_CHECK(cudaGetDevice(&devId));
-  int smemPerBlk;
-  CUDA_CHECK(cudaDeviceGetAttribute(&smemPerBlk,
-                                    cudaDevAttrMaxSharedMemoryPerBlock, devId));
-  return smemPerBlk;
-}
-
-/** helper method to get multi-processor count parameter */
-inline int getMultiProcessorCount() {
-  int devId;
-  CUDA_CHECK(cudaGetDevice(&devId));
-  int mpCount;
-  CUDA_CHECK(
-    cudaDeviceGetAttribute(&mpCount, cudaDevAttrMultiProcessorCount, devId));
-  return mpCount;
-}
-
-/** helper method to convert an array on device to a string on host */
-template <typename T>
-std::string arr2Str(const T* arr, int size, std::string name,
-                    cudaStream_t stream, int width = 4) {
-  std::stringstream ss;
-
-  T* arr_h = (T*)malloc(size * sizeof(T));
-  update_host(arr_h, arr, size, stream);
-  CUDA_CHECK(cudaStreamSynchronize(stream));
-
-  ss << name << " = [ ";
-  for (int i = 0; i < size; i++) {
-    ss << std::setw(width) << arr_h[i];
-
-    if (i < size - 1) ss << ", ";
-  }
-  ss << " ]" << std::endl;
-
-  free(arr_h);
-
-  return ss.str();
-}
-
-/** this seems to be unused, but may be useful in the future */
-template <typename T>
-void ASSERT_DEVICE_MEM(T* ptr, std::string name) {
-  cudaPointerAttributes s_att;
-  cudaError_t s_err = cudaPointerGetAttributes(&s_att, ptr);
-
-  if (s_err != 0 || s_att.device == -1)
-    std::cout << "Invalid device pointer encountered in " << name
-              << ". device=" << s_att.device << ", err=" << s_err << std::endl;
-}
-
-inline uint32_t curTimeMillis() {
-  auto now = std::chrono::high_resolution_clock::now();
-  auto duration = now.time_since_epoch();
-  return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-    .count();
-}
-
-/** Helper function to calculate need memory for allocate to store dense matrix.
-    * @param rows number of rows in matrix
-    * @param columns number of columns in matrix
-    * @return need number of items to allocate via allocate()
-    * @sa allocate()
-    */
-inline size_t allocLengthForMatrix(size_t rows, size_t columns) {
-  return rows * columns;
-}
-
-/** cuda malloc */
-template <typename Type>
-void allocate(Type*& ptr, size_t len, bool setZero = false) {
-  CUDA_CHECK(cudaMalloc((void**)&ptr, sizeof(Type) * len));
-  if (setZero) CUDA_CHECK(cudaMemset(ptr, 0, sizeof(Type) * len));
-}
-
-/** Helper function to check alignment of pointer.
-    * @param ptr the pointer to check
-    * @param alignment to be checked for
-    * @return true if address in bytes is a multiple of alignment
-    */
-template <typename Type>
-bool is_aligned(Type* ptr, size_t alignment) {
-  return reinterpret_cast<uintptr_t>(ptr) % alignment == 0;
-}
-
-/** calculate greatest common divisor of two numbers
-    * @a integer
-    * @b integer
-    * @ return gcd of a and b
-    */
-template <typename IntType>
-IntType gcd(IntType a, IntType b) {
-  while (b != 0) {
-    IntType tmp = b;
-    b = a % b;
-    a = tmp;
-  }
-  return a;
-}
-
-}  // namespace raft
diff --git a/cpp/src_prims/common/device_loads_stores.cuh b/cpp/src_prims/common/device_loads_stores.cuh
index 64cc9d3bf6..5d21d887d1 100644
--- a/cpp/src_prims/common/device_loads_stores.cuh
+++ b/cpp/src_prims/common/device_loads_stores.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/common/device_utils.cuh b/cpp/src_prims/common/device_utils.cuh
index b50451aba4..2eb6930a6d 100644
--- a/cpp/src_prims/common/device_utils.cuh
+++ b/cpp/src_prims/common/device_utils.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/common/fast_int_div.cuh b/cpp/src_prims/common/fast_int_div.cuh
index 7298320e5e..9069b3e542 100644
--- a/cpp/src_prims/common/fast_int_div.cuh
+++ b/cpp/src_prims/common/fast_int_div.cuh
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <stdint.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/common/grid_sync.cuh b/cpp/src_prims/common/grid_sync.cuh
index 3d109f1b00..00203a20eb 100644
--- a/cpp/src_prims/common/grid_sync.cuh
+++ b/cpp/src_prims/common/grid_sync.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/common/iota.cuh b/cpp/src_prims/common/iota.cuh
index c8596a6a52..f26a42b65f 100644
--- a/cpp/src_prims/common/iota.cuh
+++ b/cpp/src_prims/common/iota.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/common/scatter.cuh b/cpp/src_prims/common/scatter.cuh
deleted file mode 100644
index 6adda8e46d..0000000000
--- a/cpp/src_prims/common/scatter.cuh
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <cuda_utils.cuh>
-#include <vectorized.cuh>
-
-namespace raft {
-
-template <typename DataT, int VecLen, typename Lambda, typename IdxT>
-__global__ void scatterKernel(DataT *out, const DataT *in, const IdxT *idx,
-                              IdxT len, Lambda op) {
-  typedef TxN_t<DataT, VecLen> DataVec;
-  typedef TxN_t<IdxT, VecLen> IdxVec;
-  IdxT tid = threadIdx.x + ((IdxT)blockIdx.x * blockDim.x);
-  tid *= VecLen;
-  if (tid >= len) return;
-  IdxVec idxIn;
-  idxIn.load(idx, tid);
-  DataVec dataIn;
-#pragma unroll
-  for (int i = 0; i < VecLen; ++i) {
-    auto inPos = idxIn.val.data[i];
-    dataIn.val.data[i] = op(in[inPos], tid + i);
-  }
-  dataIn.store(out, tid);
-}
-
-template <typename DataT, int VecLen, typename Lambda, typename IdxT, int TPB>
-void scatterImpl(DataT *out, const DataT *in, const IdxT *idx, IdxT len,
-                 Lambda op, cudaStream_t stream) {
-  const IdxT nblks = raft::ceildiv(VecLen ? len / VecLen : len, (IdxT)TPB);
-  scatterKernel<DataT, VecLen, Lambda, IdxT>
-    <<<nblks, TPB, 0, stream>>>(out, in, idx, len, op);
-  CUDA_CHECK(cudaGetLastError());
-}
-
-/**
-     * @brief Performs scatter operation based on the input indexing array
-     * @tparam DataT data type whose array gets scattered
-     * @tparam IdxT indexing type
-     * @tparam TPB threads-per-block in the final kernel launched
-     * @tparam Lambda the device-lambda performing a unary operation on the loaded
-     * data before it gets scattered
-     * @param out the output array
-     * @param in the input array
-     * @param idx the indexing array
-     * @param len number of elements in the input array
-     * @param stream cuda stream where to launch work
-     * @param op the device-lambda with signature `DataT func(DataT, IdxT);`. This
-     * will be applied to every element before scattering it to the right location.
-     * The second param in this method will be the destination index.
-     */
-template <typename DataT, typename IdxT,
-          typename Lambda = raft::Nop<DataT, IdxT>, int TPB = 256>
-void scatter(DataT *out, const DataT *in, const IdxT *idx, IdxT len,
-             cudaStream_t stream, Lambda op = raft::Nop<DataT, IdxT>()) {
-  if (len <= 0) return;
-  constexpr size_t DataSize = sizeof(DataT);
-  constexpr size_t IdxSize = sizeof(IdxT);
-  constexpr size_t MaxPerElem = DataSize > IdxSize ? DataSize : IdxSize;
-  size_t bytes = len * MaxPerElem;
-  if (16 / MaxPerElem && bytes % 16 == 0) {
-    scatterImpl<DataT, 16 / MaxPerElem, Lambda, IdxT, TPB>(out, in, idx, len,
-                                                           op, stream);
-  } else if (8 / MaxPerElem && bytes % 8 == 0) {
-    scatterImpl<DataT, 8 / MaxPerElem, Lambda, IdxT, TPB>(out, in, idx, len, op,
-                                                          stream);
-  } else if (4 / MaxPerElem && bytes % 4 == 0) {
-    scatterImpl<DataT, 4 / MaxPerElem, Lambda, IdxT, TPB>(out, in, idx, len, op,
-                                                          stream);
-  } else if (2 / MaxPerElem && bytes % 2 == 0) {
-    scatterImpl<DataT, 2 / MaxPerElem, Lambda, IdxT, TPB>(out, in, idx, len, op,
-                                                          stream);
-  } else if (1 / MaxPerElem) {
-    scatterImpl<DataT, 1 / MaxPerElem, Lambda, IdxT, TPB>(out, in, idx, len, op,
-                                                          stream);
-  } else {
-    scatterImpl<DataT, 1, Lambda, IdxT, TPB>(out, in, idx, len, op, stream);
-  }
-}
-
-}  // namespace raft
diff --git a/cpp/src_prims/common/seive.cuh b/cpp/src_prims/common/seive.cuh
index d4b7d47927..f19180422a 100644
--- a/cpp/src_prims/common/seive.cuh
+++ b/cpp/src_prims/common/seive.cuh
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 
 // Taken from:
diff --git a/cpp/src_prims/cuda_utils.cuh b/cpp/src_prims/cuda_utils.cuh
deleted file mode 100644
index d542e06ec5..0000000000
--- a/cpp/src_prims/cuda_utils.cuh
+++ /dev/null
@@ -1,651 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <math_constants.h>
-#include <stdint.h>
-#include <cuml/common/utils.hpp>
-
-#ifndef ENABLE_MEMCPY_ASYNC
-// enable memcpy_async interface by default for newer GPUs
-#if __CUDA_ARCH__ >= 800
-#define ENABLE_MEMCPY_ASYNC 1
-#endif
-#else  // ENABLE_MEMCPY_ASYNC
-// disable memcpy_async for all older GPUs
-#if __CUDA_ARCH__ < 800
-#define ENABLE_MEMCPY_ASYNC 0
-#endif
-#endif  // ENABLE_MEMCPY_ASYNC
-
-namespace raft {
-
-/** helper macro for device inlined functions */
-#define DI inline __device__
-#define HDI inline __host__ __device__
-#define HD __host__ __device__
-
-/**
- * @brief Provide a ceiling division operation ie. ceil(a / b)
- * @tparam IntType supposed to be only integers for now!
- */
-template <typename IntType>
-constexpr HDI IntType ceildiv(IntType a, IntType b) {
-  return (a + b - 1) / b;
-}
-
-/**
- * @brief Provide an alignment function ie. ceil(a / b) * b
- * @tparam IntType supposed to be only integers for now!
- */
-template <typename IntType>
-constexpr HDI IntType alignTo(IntType a, IntType b) {
-  return ceildiv(a, b) * b;
-}
-
-/**
- * @brief Provide an alignment function ie. (a / b) * b
- * @tparam IntType supposed to be only integers for now!
- */
-template <typename IntType>
-constexpr HDI IntType alignDown(IntType a, IntType b) {
-  return (a / b) * b;
-}
-
-/**
- * @brief Check if the input is a power of 2
- * @tparam IntType data type (checked only for integers)
- */
-template <typename IntType>
-constexpr HDI bool isPo2(IntType num) {
-  return (num && !(num & (num - 1)));
-}
-
-/**
- * @brief Give logarithm of the number to base-2
- * @tparam IntType data type (checked only for integers)
- */
-template <typename IntType>
-constexpr HDI IntType log2(IntType num, IntType ret = IntType(0)) {
-  return num <= IntType(1) ? ret : log2(num >> IntType(1), ++ret);
-}
-
-/** Device function to apply the input lambda across threads in the grid */
-template <int ItemsPerThread, typename L>
-DI void forEach(int num, L lambda) {
-  int idx = (blockDim.x * blockIdx.x) + threadIdx.x;
-  const int numThreads = blockDim.x * gridDim.x;
-#pragma unroll
-  for (int itr = 0; itr < ItemsPerThread; ++itr, idx += numThreads) {
-    if (idx < num) lambda(idx, itr);
-  }
-}
-
-/** number of threads per warp */
-static const int WarpSize = 32;
-
-/** get the laneId of the current thread */
-DI int laneId() {
-  int id;
-  asm("mov.s32 %0, %laneid;" : "=r"(id));
-  return id;
-}
-
-/**
- * @brief Swap two values
- * @tparam T the datatype of the values
- * @param a first input
- * @param b second input
- */
-template <typename T>
-HDI void swapVals(T &a, T &b) {
-  T tmp = a;
-  a = b;
-  b = tmp;
-}
-
-/** Device function to have atomic add support for older archs */
-template <typename Type>
-DI void myAtomicAdd(Type *address, Type val) {
-  atomicAdd(address, val);
-}
-
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 600)
-// Ref:
-// http://on-demand.gputechconf.com/gtc/2013/presentations/S3101-Atomic-Memory-Operations.pdf
-template <>
-DI void myAtomicAdd(double *address, double val) {
-  unsigned long long int *address_as_ull = (unsigned long long int *)address;
-  unsigned long long int old = *address_as_ull, assumed;
-  do {
-    assumed = old;
-    old = atomicCAS(address_as_ull, assumed,
-                    __double_as_longlong(val + __longlong_as_double(assumed)));
-  } while (assumed != old);
-}
-#endif
-
-template <typename T, typename ReduceLambda>
-DI void myAtomicReduce(T *address, T val, ReduceLambda op);
-
-template <typename ReduceLambda>
-DI void myAtomicReduce(double *address, double val, ReduceLambda op) {
-  unsigned long long int *address_as_ull = (unsigned long long int *)address;
-  unsigned long long int old = *address_as_ull, assumed;
-  do {
-    assumed = old;
-    old =
-      atomicCAS(address_as_ull, assumed,
-                __double_as_longlong(op(val, __longlong_as_double(assumed))));
-  } while (assumed != old);
-}
-
-template <typename ReduceLambda>
-DI void myAtomicReduce(float *address, float val, ReduceLambda op) {
-  unsigned int *address_as_uint = (unsigned int *)address;
-  unsigned int old = *address_as_uint, assumed;
-  do {
-    assumed = old;
-    old = atomicCAS(address_as_uint, assumed,
-                    __float_as_uint(op(val, __uint_as_float(assumed))));
-  } while (assumed != old);
-}
-
-template <typename ReduceLambda>
-DI void myAtomicReduce(int *address, int val, ReduceLambda op) {
-  int old = *address, assumed;
-  do {
-    assumed = old;
-    old = atomicCAS(address, assumed, op(val, assumed));
-  } while (assumed != old);
-}
-
-template <typename ReduceLambda>
-DI void myAtomicReduce(long long *address, long long val, ReduceLambda op) {
-  long long old = *address, assumed;
-  do {
-    assumed = old;
-    old = atomicCAS(address, assumed, op(val, assumed));
-  } while (assumed != old);
-}
-
-template <typename ReduceLambda>
-DI void myAtomicReduce(unsigned long long *address, unsigned long long val,
-                       ReduceLambda op) {
-  unsigned long long old = *address, assumed;
-  do {
-    assumed = old;
-    old = atomicCAS(address, assumed, op(val, assumed));
-  } while (assumed != old);
-}
-
-/**
- * @brief Provide atomic min operation.
- * @tparam T: data type for input data (float or double).
- * @param[in] address: address to read old value from, and to atomically update w/ min(old value, val)
- * @param[in] val: new value to compare with old
- */
-template <typename T>
-DI T myAtomicMin(T *address, T val);
-
-/**
- * @brief Provide atomic max operation.
- * @tparam T: data type for input data (float or double).
- * @param[in] address: address to read old value from, and to atomically update w/ max(old value, val)
- * @param[in] val: new value to compare with old
- */
-template <typename T>
-DI T myAtomicMax(T *address, T val);
-
-DI float myAtomicMin(float *address, float val) {
-  myAtomicReduce(address, val, fminf);
-  return *address;
-}
-
-DI float myAtomicMax(float *address, float val) {
-  myAtomicReduce(address, val, fmaxf);
-  return *address;
-}
-
-DI double myAtomicMin(double *address, double val) {
-  myAtomicReduce<double(double, double)>(address, val, fmin);
-  return *address;
-}
-
-DI double myAtomicMax(double *address, double val) {
-  myAtomicReduce<double(double, double)>(address, val, fmax);
-  return *address;
-}
-
-/**
- * @defgroup Max maximum of two numbers
- * @{
- */
-template <typename T>
-HDI T myMax(T x, T y);
-template <>
-HDI float myMax<float>(float x, float y) {
-  return fmaxf(x, y);
-}
-template <>
-HDI double myMax<double>(double x, double y) {
-  return fmax(x, y);
-}
-/** @} */
-
-/**
- * @defgroup Min minimum of two numbers
- * @{
- */
-template <typename T>
-HDI T myMin(T x, T y);
-template <>
-HDI float myMin<float>(float x, float y) {
-  return fminf(x, y);
-}
-template <>
-HDI double myMin<double>(double x, double y) {
-  return fmin(x, y);
-}
-/** @} */
-
-/**
- * @brief Provide atomic min operation.
- * @tparam T: data type for input data (float or double).
- * @param[in] address: address to read old value from, and to atomically update w/ min(old value, val)
- * @param[in] val: new value to compare with old
- */
-template <typename T>
-DI T myAtomicMin(T *address, T val) {
-  myAtomicReduce(address, val, myMin<T>);
-  return *address;
-}
-
-/**
- * @brief Provide atomic max operation.
- * @tparam T: data type for input data (float or double).
- * @param[in] address: address to read old value from, and to atomically update w/ max(old value, val)
- * @param[in] val: new value to compare with old
- */
-template <typename T>
-DI T myAtomicMax(T *address, T val) {
-  myAtomicReduce(address, val, myMax<T>);
-  return *address;
-}
-
-/**
- * Sign function
- */
-template <typename T>
-HDI int sgn(const T val) {
-  return (T(0) < val) - (val < T(0));
-}
-
-/**
- * @defgroup Exp Exponential function
- * @{
- */
-template <typename T>
-HDI T myExp(T x);
-template <>
-HDI float myExp(float x) {
-  return expf(x);
-}
-template <>
-HDI double myExp(double x) {
-  return exp(x);
-}
-/** @} */
-
-/**
- * @defgroup Cuda infinity values
- * @{
- */
-template <typename T>
-inline __device__ T myInf();
-template <>
-inline __device__ float myInf<float>() {
-  return CUDART_INF_F;
-}
-template <>
-inline __device__ double myInf<double>() {
-  return CUDART_INF;
-}
-/** @} */
-
-/**
- * @defgroup Log Natural logarithm
- * @{
- */
-template <typename T>
-HDI T myLog(T x);
-template <>
-HDI float myLog(float x) {
-  return logf(x);
-}
-template <>
-HDI double myLog(double x) {
-  return log(x);
-}
-/** @} */
-
-/**
- * @defgroup Sqrt Square root
- * @{
- */
-template <typename T>
-HDI T mySqrt(T x);
-template <>
-HDI float mySqrt(float x) {
-  return sqrtf(x);
-}
-template <>
-HDI double mySqrt(double x) {
-  return sqrt(x);
-}
-/** @} */
-
-/**
- * @defgroup SineCosine Sine and cosine calculation
- * @{
- */
-template <typename T>
-DI void mySinCos(T x, T &s, T &c);
-template <>
-DI void mySinCos(float x, float &s, float &c) {
-  sincosf(x, &s, &c);
-}
-template <>
-DI void mySinCos(double x, double &s, double &c) {
-  sincos(x, &s, &c);
-}
-/** @} */
-
-/**
- * @defgroup Sine Sine calculation
- * @{
- */
-template <typename T>
-DI T mySin(T x);
-template <>
-DI float mySin(float x) {
-  return sinf(x);
-}
-template <>
-DI double mySin(double x) {
-  return sin(x);
-}
-/** @} */
-
-/**
- * @defgroup Abs Absolute value
- * @{
- */
-template <typename T>
-DI T myAbs(T x) {
-  return x < 0 ? -x : x;
-}
-template <>
-DI float myAbs(float x) {
-  return fabsf(x);
-}
-template <>
-DI double myAbs(double x) {
-  return fabs(x);
-}
-/** @} */
-
-/**
- * @defgroup Pow Power function
- * @{
- */
-template <typename T>
-HDI T myPow(T x, T power);
-template <>
-HDI float myPow(float x, float power) {
-  return powf(x, power);
-}
-template <>
-HDI double myPow(double x, double power) {
-  return pow(x, power);
-}
-/** @} */
-
-/**
- * @defgroup myTanh tanh function
- * @{
- */
-template <typename T>
-HDI T myTanh(T x);
-template <>
-HDI float myTanh(float x) {
-  return tanhf(x);
-}
-template <>
-HDI double myTanh(double x) {
-  return tanh(x);
-}
-/** @} */
-
-/**
- * @defgroup myATanh arctanh function
- * @{
- */
-template <typename T>
-HDI T myATanh(T x);
-template <>
-HDI float myATanh(float x) {
-  return atanhf(x);
-}
-template <>
-HDI double myATanh(double x) {
-  return atanh(x);
-}
-/** @} */
-
-/**
- * @defgroup LambdaOps Lambda operations in reduction kernels
- * @{
- */
-// IdxType mostly to be used for MainLambda in *Reduction kernels
-template <typename Type, typename IdxType = int>
-struct Nop {
-  HDI Type operator()(Type in, IdxType i = 0) { return in; }
-};
-
-template <typename Type, typename IdxType = int>
-struct L1Op {
-  HDI Type operator()(Type in, IdxType i = 0) { return myAbs(in); }
-};
-
-template <typename Type, typename IdxType = int>
-struct L2Op {
-  HDI Type operator()(Type in, IdxType i = 0) { return in * in; }
-};
-
-template <typename Type>
-struct Sum {
-  HDI Type operator()(Type a, Type b) { return a + b; }
-};
-/** @} */
-
-/**
- * @defgroup Sign Obtain sign value
- * @brief Obtain sign of x
- * @param x input
- * @return +1 if x >= 0 and -1 otherwise
- * @{
- */
-template <typename T>
-DI T signPrim(T x) {
-  return x < 0 ? -1 : +1;
-}
-template <>
-DI float signPrim(float x) {
-  return signbit(x) == true ? -1.0f : +1.0f;
-}
-template <>
-DI double signPrim(double x) {
-  return signbit(x) == true ? -1.0 : +1.0;
-}
-/** @} */
-
-/**
- * @defgroup Max maximum of two numbers
- * @brief Obtain maximum of two values
- * @param x one item
- * @param y second item
- * @return maximum of two items
- * @{
- */
-template <typename T>
-DI T maxPrim(T x, T y) {
-  return x > y ? x : y;
-}
-template <>
-DI float maxPrim(float x, float y) {
-  return fmaxf(x, y);
-}
-template <>
-DI double maxPrim(double x, double y) {
-  return fmax(x, y);
-}
-/** @} */
-
-/** apply a warp-wide fence (useful from Volta+ archs) */
-DI void warpFence() {
-#if __CUDA_ARCH__ >= 700
-  __syncwarp();
-#endif
-}
-
-/** warp-wide any boolean aggregator */
-DI bool any(bool inFlag, uint32_t mask = 0xffffffffu) {
-#if CUDART_VERSION >= 9000
-  inFlag = __any_sync(mask, inFlag);
-#else
-  inFlag = __any(inFlag);
-#endif
-  return inFlag;
-}
-
-/** warp-wide all boolean aggregator */
-DI bool all(bool inFlag, uint32_t mask = 0xffffffffu) {
-#if CUDART_VERSION >= 9000
-  inFlag = __all_sync(mask, inFlag);
-#else
-  inFlag = __all(inFlag);
-#endif
-  return inFlag;
-}
-
-/**
- * @brief Shuffle the data inside a warp
- * @tparam T the data type (currently assumed to be 4B)
- * @param val value to be shuffled
- * @param srcLane lane from where to shuffle
- * @param width lane width
- * @param mask mask of participating threads (Volta+)
- * @return the shuffled data
- */
-template <typename T>
-DI T shfl(T val, int srcLane, int width = WarpSize,
-          uint32_t mask = 0xffffffffu) {
-#if CUDART_VERSION >= 9000
-  return __shfl_sync(mask, val, srcLane, width);
-#else
-  return __shfl(val, srcLane, width);
-#endif
-}
-
-/**
- * @brief Shuffle the data inside a warp
- * @tparam T the data type (currently assumed to be 4B)
- * @param val value to be shuffled
- * @param laneMask mask to be applied in order to perform xor shuffle
- * @param width lane width
- * @param mask mask of participating threads (Volta+)
- * @return the shuffled data
- */
-template <typename T>
-DI T shfl_xor(T val, int laneMask, int width = WarpSize,
-              uint32_t mask = 0xffffffffu) {
-#if CUDART_VERSION >= 9000
-  return __shfl_xor_sync(mask, val, laneMask, width);
-#else
-  return __shfl_xor(val, laneMask, width);
-#endif
-}
-
-/**
- * @brief Warp-level sum reduction
- * @param val input value
- * @return only the lane0 will contain valid reduced result
- * @note Why not cub? Because cub doesn't seem to allow working with arbitrary
- *       number of warps in a block. All threads in the warp must enter this
- *       function together
- * @todo Expand this to support arbitrary reduction ops
- */
-template <typename T>
-DI T warpReduce(T val) {
-#pragma unroll
-  for (int i = WarpSize / 2; i > 0; i >>= 1) {
-    T tmp = shfl(val, laneId() + i);
-    val += tmp;
-  }
-  return val;
-}
-
-/**
- * @brief 1-D block-level sum reduction
- * @param val input value
- * @param smem shared memory region needed for storing intermediate results. It
- *             must alteast be of size: `sizeof(T) * nWarps`
- * @return only the thread0 will contain valid reduced result
- * @note Why not cub? Because cub doesn't seem to allow working with arbitrary
- *       number of warps in a block. All threads in the block must enter this
- *       function together
- * @todo Expand this to support arbitrary reduction ops
- */
-template <typename T>
-DI T blockReduce(T val, char *smem) {
-  auto *sTemp = reinterpret_cast<T *>(smem);
-  int nWarps = (blockDim.x + WarpSize - 1) / WarpSize;
-  int lid = laneId();
-  int wid = threadIdx.x / WarpSize;
-  val = warpReduce(val);
-  if (lid == 0) sTemp[wid] = val;
-  __syncthreads();
-  val = lid < nWarps ? sTemp[lid] : T(0);
-  return warpReduce(val);
-}
-
-/**
- * @brief Simple utility function to determine whether user_stream or one of the
- * internal streams should be used.
- * @param user_stream main user stream
- * @param int_streams array of internal streams
- * @param n_int_streams number of internal streams
- * @param idx the index for which to query the stream
- */
-inline cudaStream_t select_stream(cudaStream_t user_stream,
-                                  cudaStream_t *int_streams, int n_int_streams,
-                                  int idx) {
-  return n_int_streams > 0 ? int_streams[idx % n_int_streams] : user_stream;
-}
-
-}  // namespace raft
diff --git a/cpp/src_prims/decoupled_lookback.cuh b/cpp/src_prims/decoupled_lookback.cuh
index 877c4b9373..5d1f71b423 100644
--- a/cpp/src_prims/decoupled_lookback.cuh
+++ b/cpp/src_prims/decoupled_lookback.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include "cuda_utils.cuh"
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/distance/algo1.cuh b/cpp/src_prims/distance/algo1.cuh
index 2d03bd3ea1..700d16d721 100644
--- a/cpp/src_prims/distance/algo1.cuh
+++ b/cpp/src_prims/distance/algo1.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <linalg/gemm.cuh>
-#include <linalg/norm.cuh>
+#include <linalg/cutlass_gemm.cuh>
+#include <raft/linalg/norm.cuh>
 #include "distance_epilogue.cuh"
 #include "distance_epilogue_functor.cuh"
 #include "distance_epilogue_traits.h"
diff --git a/cpp/src_prims/distance/distance.cuh b/cpp/src_prims/distance/distance.cuh
index 814039b8be..6f822f6323 100644
--- a/cpp/src_prims/distance/distance.cuh
+++ b/cpp/src_prims/distance/distance.cuh
@@ -20,7 +20,7 @@
 #include <cuml/distance/distance_type.h>
 #include <cutlass/shape.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "cosine.cuh"
 #include "euclidean.cuh"
 #include "l1.cuh"
diff --git a/cpp/src_prims/distance/distance_fragment_multiply_add.cuh b/cpp/src_prims/distance/distance_fragment_multiply_add.cuh
index 80f03d77f7..513181272d 100644
--- a/cpp/src_prims/distance/distance_fragment_multiply_add.cuh
+++ b/cpp/src_prims/distance/distance_fragment_multiply_add.cuh
@@ -17,7 +17,7 @@
 #pragma once
 #include <cutlass/fragment.h>
 #include <cutlass/shape.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Distance {
diff --git a/cpp/src_prims/distance/euclidean.cuh b/cpp/src_prims/distance/euclidean.cuh
index 7bd7a08597..cef156a536 100644
--- a/cpp/src_prims/distance/euclidean.cuh
+++ b/cpp/src_prims/distance/euclidean.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 #include <linalg/custom_accum.h>
+#include <linalg/cutlass_gemm.cuh>
 #include <linalg/eltwise2d.cuh>
-#include <linalg/gemm.cuh>
 #include "algo1.cuh"
 #include "distance_fragment_multiply_add.cuh"
 
diff --git a/cpp/src_prims/distance/fragment_sqrt.cuh b/cpp/src_prims/distance/fragment_sqrt.cuh
index 924915413b..d771d91ada 100644
--- a/cpp/src_prims/distance/fragment_sqrt.cuh
+++ b/cpp/src_prims/distance/fragment_sqrt.cuh
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <cutlass/fragment_multiply_add.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Distance {
diff --git a/cpp/src_prims/distance/fused_l2_nn.cuh b/cpp/src_prims/distance/fused_l2_nn.cuh
index 06d8c12257..a32bafbf76 100644
--- a/cpp/src_prims/distance/fused_l2_nn.cuh
+++ b/cpp/src_prims/distance/fused_l2_nn.cuh
@@ -18,9 +18,9 @@
 
 #include <stdint.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <limits>
 #include <linalg/contractions.cuh>
+#include <raft/cuda_utils.cuh>
 
 #if (ENABLE_MEMCPY_ASYNC == 1)
 #include <cuda_pipeline.h>
diff --git a/cpp/src_prims/distance/l1.cuh b/cpp/src_prims/distance/l1.cuh
index 6cbf4fc3f6..0a1fca828d 100644
--- a/cpp/src_prims/distance/l1.cuh
+++ b/cpp/src_prims/distance/l1.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 #include <linalg/custom_accum.h>
-#include <linalg/gemm.cuh>
+#include <linalg/cutlass_gemm.cuh>
 
 #include <type_traits>
 
diff --git a/cpp/src_prims/functions/hinge.cuh b/cpp/src_prims/functions/hinge.cuh
index da22b6f036..029bf337a8 100644
--- a/cpp/src_prims/functions/hinge.cuh
+++ b/cpp/src_prims/functions/hinge.cuh
@@ -16,21 +16,21 @@
 
 #pragma once
 
-#include <linalg/transpose.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/subtract.cuh>
-#include <linalg/unary_op.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <raft/mr/device/buffer.hpp>
-#include <stats/mean.cuh>
-#include <stats/sum.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/sum.cuh>
 #include "penalty.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/functions/linearReg.cuh b/cpp/src_prims/functions/linearReg.cuh
index a7f2c55d0c..78f9221b90 100644
--- a/cpp/src_prims/functions/linearReg.cuh
+++ b/cpp/src_prims/functions/linearReg.cuh
@@ -16,19 +16,19 @@
 
 #pragma once
 
-#include <linalg/transpose.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/subtract.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <raft/mr/device/buffer.hpp>
-#include <stats/mean.cuh>
-#include <stats/sum.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/sum.cuh>
 #include "penalty.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/functions/log.cuh b/cpp/src_prims/functions/log.cuh
index b28dd8559f..d6d32a14a1 100644
--- a/cpp/src_prims/functions/log.cuh
+++ b/cpp/src_prims/functions/log.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Functions {
diff --git a/cpp/src_prims/functions/logisticReg.cuh b/cpp/src_prims/functions/logisticReg.cuh
index 0f8d14bc8e..567f9337b4 100644
--- a/cpp/src_prims/functions/logisticReg.cuh
+++ b/cpp/src_prims/functions/logisticReg.cuh
@@ -16,19 +16,19 @@
 
 #pragma once
 
-#include <linalg/transpose.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/binary_op.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/gemm.cuh>
-#include <linalg/subtract.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <stats/mean.cuh>
-#include <stats/sum.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/sum.cuh>
 #include "penalty.cuh"
 #include "sigmoid.cuh"
 
diff --git a/cpp/src_prims/functions/penalty.cuh b/cpp/src_prims/functions/penalty.cuh
index 00d3058966..8a66cada51 100644
--- a/cpp/src_prims/functions/penalty.cuh
+++ b/cpp/src_prims/functions/penalty.cuh
@@ -16,13 +16,13 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
-#include <linalg/add.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/norm.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "sign.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/functions/sigmoid.cuh b/cpp/src_prims/functions/sigmoid.cuh
index 118d14f147..98a6ade4c1 100644
--- a/cpp/src_prims/functions/sigmoid.cuh
+++ b/cpp/src_prims/functions/sigmoid.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Functions {
diff --git a/cpp/src_prims/functions/sign.cuh b/cpp/src_prims/functions/sign.cuh
index fd4d37eaff..85abc70f16 100644
--- a/cpp/src_prims/functions/sign.cuh
+++ b/cpp/src_prims/functions/sign.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Functions {
diff --git a/cpp/src_prims/functions/softThres.cuh b/cpp/src_prims/functions/softThres.cuh
index 2bb1390597..4f7306633d 100644
--- a/cpp/src_prims/functions/softThres.cuh
+++ b/cpp/src_prims/functions/softThres.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Functions {
diff --git a/cpp/src_prims/label/classlabels.cuh b/cpp/src_prims/label/classlabels.cuh
index 8dc1973781..4fbe1b3641 100644
--- a/cpp/src_prims/label/classlabels.cuh
+++ b/cpp/src_prims/label/classlabels.cuh
@@ -18,11 +18,11 @@
 
 #include <cub/cub.cuh>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Label {
diff --git a/cpp/src_prims/linalg/add.cuh b/cpp/src_prims/linalg/add.cuh
deleted file mode 100644
index 7a454f64e2..0000000000
--- a/cpp/src_prims/linalg/add.cuh
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 "binary_op.cuh"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief Elementwise scalar add operation on the input buffer
- *
- * @tparam InT     input data-type. Also the data-type upon which the math ops
- *                 will be performed
- * @tparam OutT    output data-type
- * @tparam IdxType Integer type used to for addressing
- *
- * @param out    the output buffer
- * @param in     the input buffer
- * @param scalar the scalar used in the operations
- * @param len    number of elements in the input buffer
- * @param stream cuda stream where to launch work
- */
-template <typename InT, typename OutT = InT, typename IdxType = int>
-void addScalar(OutT *out, const InT *in, InT scalar, IdxType len,
-               cudaStream_t stream) {
-  auto op = [scalar] __device__(InT in) { return OutT(in + scalar); };
-  unaryOp<InT, decltype(op), IdxType, OutT>(out, in, len, op, stream);
-}
-
-/**
- * @brief Elementwise add operation on the input buffers
- * @tparam InT     input data-type. Also the data-type upon which the math ops
- *                 will be performed
- * @tparam OutT    output data-type
- * @tparam IdxType Integer type used to for addressing
- *
- * @param out    the output buffer
- * @param in1    the first input buffer
- * @param in2    the second input buffer
- * @param len    number of elements in the input buffers
- * @param stream cuda stream where to launch work
- */
-template <typename InT, typename OutT = InT, typename IdxType = int>
-void add(OutT *out, const InT *in1, const InT *in2, IdxType len,
-         cudaStream_t stream) {
-  auto op = [] __device__(InT a, InT b) { return OutT(a + b); };
-  binaryOp<InT, decltype(op), OutT, IdxType>(out, in1, in2, len, op, stream);
-}
-
-template <class math_t, typename IdxType>
-__global__ void add_dev_scalar_kernel(math_t *outDev, const math_t *inDev,
-                                      const math_t *singleScalarDev,
-                                      IdxType len) {
-  IdxType i = ((IdxType)blockIdx.x * (IdxType)blockDim.x) + threadIdx.x;
-  if (i < len) {
-    outDev[i] = inDev[i] + *singleScalarDev;
-  }
-}
-
-/** Substract single value pointed by singleScalarDev parameter in device memory from inDev[i] and write result to outDev[i]
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param outDev the output buffer
- * @param inDev the input buffer
- * @param singleScalarDev pointer to the scalar located in device memory
- * @param len number of elements in the input and output buffer
- * @param stream cuda stream
- */
-template <typename math_t, typename IdxType = int>
-void addDevScalar(math_t *outDev, const math_t *inDev,
-                  const math_t *singleScalarDev, IdxType len,
-                  cudaStream_t stream) {
-  // TODO: block dimension has not been tuned
-  dim3 block(256);
-  dim3 grid(raft::ceildiv(len, (IdxType)block.x));
-  add_dev_scalar_kernel<math_t>
-    <<<grid, block, 0, stream>>>(outDev, inDev, singleScalarDev, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/batched/gemv.cuh b/cpp/src_prims/linalg/batched/gemv.cuh
index 287197ea88..9b85f531bd 100644
--- a/cpp/src_prims/linalg/batched/gemv.cuh
+++ b/cpp/src_prims/linalg/batched/gemv.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <vectorized.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/vectorized.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/batched/make_symm.cuh b/cpp/src_prims/linalg/batched/make_symm.cuh
index 3ee3241b01..199bfdedbb 100644
--- a/cpp/src_prims/linalg/batched/make_symm.cuh
+++ b/cpp/src_prims/linalg/batched/make_symm.cuh
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/batched/matrix.cuh b/cpp/src_prims/linalg/batched/matrix.cuh
index af73f77d63..724a4eeeda 100644
--- a/cpp/src_prims/linalg/batched/matrix.cuh
+++ b/cpp/src_prims/linalg/batched/matrix.cuh
@@ -28,16 +28,16 @@
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <common/fast_int_div.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/utils.hpp>
 #include <cuml/cuml.hpp>
+#include <raft/cuda_utils.cuh>
 
 #include <raft/linalg/cublas_wrappers.h>
-#include "../binary_op.cuh"
-#include "../unary_op.cuh"
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/binary_op.cuh b/cpp/src_prims/linalg/binary_op.cuh
deleted file mode 100644
index 7367f7fddb..0000000000
--- a/cpp/src_prims/linalg/binary_op.cuh
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <vectorized.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename InType, int VecLen, typename Lambda, typename IdxType,
-          typename OutType>
-__global__ void binaryOpKernel(OutType *out, const InType *in1,
-                               const InType *in2, IdxType len, Lambda op) {
-  typedef TxN_t<InType, VecLen> InVecType;
-  typedef TxN_t<OutType, VecLen> OutVecType;
-  InVecType a, b;
-  OutVecType c;
-  IdxType idx = threadIdx.x + ((IdxType)blockIdx.x * blockDim.x);
-  idx *= InVecType::Ratio;
-  if (idx >= len) return;
-  a.load(in1, idx);
-  b.load(in2, idx);
-#pragma unroll
-  for (int i = 0; i < InVecType::Ratio; ++i) {
-    c.val.data[i] = op(a.val.data[i], b.val.data[i]);
-  }
-  c.store(out, idx);
-}
-
-template <typename InType, int VecLen, typename Lambda, typename IdxType,
-          typename OutType, int TPB>
-void binaryOpImpl(OutType *out, const InType *in1, const InType *in2,
-                  IdxType len, Lambda op, cudaStream_t stream) {
-  const IdxType nblks =
-    raft::ceildiv(VecLen ? len / VecLen : len, (IdxType)TPB);
-  binaryOpKernel<InType, VecLen, Lambda, IdxType, OutType>
-    <<<nblks, TPB, 0, stream>>>(out, in1, in2, len, op);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief perform element-wise binary operation on the input arrays
- * @tparam InType input data-type
- * @tparam Lambda the device-lambda performing the actual operation
- * @tparam OutType output data-type
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads-per-block in the final kernel launched
- * @param out the output array
- * @param in1 the first input array
- * @param in2 the second input array
- * @param len number of elements in the input array
- * @param op the device-lambda
- * @param stream cuda stream where to launch work
- * @note Lambda must be a functor with the following signature:
- *       `OutType func(const InType& val1, const InType& val2);`
- */
-template <typename InType, typename Lambda, typename OutType = InType,
-          typename IdxType = int, int TPB = 256>
-void binaryOp(OutType *out, const InType *in1, const InType *in2, IdxType len,
-              Lambda op, cudaStream_t stream) {
-  constexpr auto maxSize =
-    sizeof(InType) > sizeof(OutType) ? sizeof(InType) : sizeof(OutType);
-  size_t bytes = len * maxSize;
-  if (16 / maxSize && bytes % 16 == 0) {
-    binaryOpImpl<InType, 16 / maxSize, Lambda, IdxType, OutType, TPB>(
-      out, in1, in2, len, op, stream);
-  } else if (8 / maxSize && bytes % 8 == 0) {
-    binaryOpImpl<InType, 8 / maxSize, Lambda, IdxType, OutType, TPB>(
-      out, in1, in2, len, op, stream);
-  } else if (4 / maxSize && bytes % 4 == 0) {
-    binaryOpImpl<InType, 4 / maxSize, Lambda, IdxType, OutType, TPB>(
-      out, in1, in2, len, op, stream);
-  } else if (2 / maxSize && bytes % 2 == 0) {
-    binaryOpImpl<InType, 2 / maxSize, Lambda, IdxType, OutType, TPB>(
-      out, in1, in2, len, op, stream);
-  } else if (1 / maxSize) {
-    binaryOpImpl<InType, 1 / maxSize, Lambda, IdxType, OutType, TPB>(
-      out, in1, in2, len, op, stream);
-  } else {
-    binaryOpImpl<InType, 1, Lambda, IdxType, OutType, TPB>(out, in1, in2, len,
-                                                           op, stream);
-  }
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/coalesced_reduction.cuh b/cpp/src_prims/linalg/coalesced_reduction.cuh
deleted file mode 100644
index 4da095c170..0000000000
--- a/cpp/src_prims/linalg/coalesced_reduction.cuh
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-
-namespace raft {
-namespace linalg {
-
-// Kernel (based on norm.cuh) to perform reductions along the coalesced dimension
-// of the matrix, i.e. reduce along rows for row major or reduce along columns
-// for column major layout. Kernel does an inplace reduction adding to original
-// values of dots.
-template <typename InType, typename OutType, typename IdxType, int TPB,
-          typename MainLambda, typename ReduceLambda, typename FinalLambda>
-__global__ void coalescedReductionKernel(OutType *dots, const InType *data,
-                                         int D, int N, OutType init,
-                                         MainLambda main_op,
-                                         ReduceLambda reduce_op,
-                                         FinalLambda final_op,
-                                         bool inplace = false) {
-  typedef cub::BlockReduce<OutType, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  OutType thread_data = init;
-  IdxType rowStart = blockIdx.x * D;
-  for (IdxType i = threadIdx.x; i < D; i += TPB) {
-    IdxType idx = rowStart + i;
-    thread_data = reduce_op(thread_data, main_op(data[idx], i));
-  }
-  OutType acc = BlockReduce(temp_storage).Reduce(thread_data, reduce_op);
-  if (threadIdx.x == 0) {
-    if (inplace) {
-      dots[blockIdx.x] = final_op(reduce_op(dots[blockIdx.x], acc));
-    } else {
-      dots[blockIdx.x] = final_op(acc);
-    }
-  }
-}
-
-/**
- * @brief Compute reduction of the input matrix along the leading dimension
- *
- * @tparam InType the data type of the input
- * @tparam OutType the data type of the output (as well as the data type for
- *  which reduction is performed)
- * @tparam IdxType data type of the indices of the array
- * @tparam MainLambda Unary lambda applied while acculumation (eg: L1 or L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*MainLambda)(InType, IdxType);</pre>
- * @tparam ReduceLambda Binary lambda applied for reduction (eg: addition(+) for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*ReduceLambda)(OutType);</pre>
- * @tparam FinalLambda the final lambda applied before STG (eg: Sqrt for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*FinalLambda)(OutType);</pre>
- * @param dots the output reduction vector
- * @param data the input matrix
- * @param D leading dimension of data
- * @param N second dimension data
- * @param init initial value to use for the reduction
- * @param main_op elementwise operation to apply before reduction
- * @param reduce_op binary reduction operation
- * @param final_op elementwise operation to apply before storing results
- * @param inplace reduction result added inplace or overwrites old values?
- * @param stream cuda stream where to launch work
- */
-template <typename InType, typename OutType = InType, typename IdxType = int,
-          typename MainLambda = raft::Nop<InType, IdxType>,
-          typename ReduceLambda = raft::Sum<OutType>,
-          typename FinalLambda = raft::Nop<OutType>>
-void coalescedReduction(OutType *dots, const InType *data, int D, int N,
-                        OutType init, cudaStream_t stream, bool inplace = false,
-                        MainLambda main_op = raft::Nop<InType, IdxType>(),
-                        ReduceLambda reduce_op = raft::Sum<OutType>(),
-                        FinalLambda final_op = raft::Nop<OutType>()) {
-  // One block per reduction
-  // Efficient only for large leading dimensions
-  if (D <= 32) {
-    coalescedReductionKernel<InType, OutType, IdxType, 32>
-      <<<N, 32, 0, stream>>>(dots, data, D, N, init, main_op, reduce_op,
-                             final_op, inplace);
-  } else if (D <= 64) {
-    coalescedReductionKernel<InType, OutType, IdxType, 64>
-      <<<N, 64, 0, stream>>>(dots, data, D, N, init, main_op, reduce_op,
-                             final_op, inplace);
-  } else if (D <= 128) {
-    coalescedReductionKernel<InType, OutType, IdxType, 128>
-      <<<N, 128, 0, stream>>>(dots, data, D, N, init, main_op, reduce_op,
-                              final_op, inplace);
-  } else {
-    coalescedReductionKernel<InType, OutType, IdxType, 256>
-      <<<N, 256, 0, stream>>>(dots, data, D, N, init, main_op, reduce_op,
-                              final_op, inplace);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/cutlass_gemm.cuh b/cpp/src_prims/linalg/cutlass_gemm.cuh
new file mode 100644
index 0000000000..f4f1e5d46f
--- /dev/null
+++ b/cpp/src_prims/linalg/cutlass_gemm.cuh
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2018-2020, 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 "cutlass_wrappers.cuh"
+
+// cutlass based gemm is being kept in this namespace so that RAFT does not
+// have to take cutlass-dependency when cublas based gemm is moved to RAFT
+namespace MLCommon {
+namespace LinAlg {
+
+/**
+  * @brief the gemm function for the cases with detailed epilogue customization
+  *  It computes the following equation: D = alpha . opA(A) * opB(B) + beta . C
+  * @tparam IType input data-type (for A and B matrices)
+  * @tparam AccType accumulation data-type
+  * @tparam OType output data-type (for C and D matrices)
+  * @tparam OutputTile_ output tile size for the thread block
+  * @tparam AccumulatorsPerThread_ number of accumulators per thread
+  * @tparam MainLoopFunctor_ custom functor to be used in the main loop
+  * @tparam Index_ the type of index
+  * @tparam GemmConfig_ the config for the GEMM
+  * @tparam EpilogueFunctor_ custom epilogue functor
+  * @tparam GemmEpilogueTraits_ epilogue traits class to build the epilogue
+  * @tparam GemmEpilogue_ custom epilogue
+  * @tparam Lambda lambda to initialize any custom params inside EpilogueFunctor_
+  * @tparam FinalLambda Final device lambda to be applied in epilogue
+  * @param transA cublas transpose op for A
+  * @param transB cublas transpose op for B
+  * @param m number of rows of A and C/D
+  * @param n number of columns of B and C/D
+  * @param k number of cols of A and rows of B
+  * @param alpha scalar
+  * @param A input matrix
+  * @param lda leading dim for A
+  * @param B input matrix
+  * @param ldb leading dim for B
+  * @param beta scalar
+  * @param C input matrix
+  * @param ldc leading dim for C and D
+  * @param D output matrix
+  * @param op lambda function to initialize any custom params inside
+  * EpilogueFunctor_
+  * @param fin_op the final lambda to be run inside the Epilogue. This can help
+  * in customizing a given EpilogueFunctor, without having to go through the task
+  * of creating another Functor!
+  * @param stream cuda stream where to launch work
+  */
+template <
+  typename IType, typename AccType, typename OType, typename OutputTile_,
+  typename AccumulatorsPerThread_ = cutlass::Shape<8, 8, 8>,
+  typename MainLoopFunctor_ = cutlass::gemm::ThreadMultiplyAdd<
+    AccumulatorsPerThread_, cutlass::Shape<1, 4, 8>, IType, IType, AccType>,
+  typename Index_ = int,
+  typename GemmConfig_ =
+    CustomGemmConfig<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
+                     MainLoopFunctor_>,
+  typename EpilogueFunctor_ = LinearScaling<OType>,
+  typename GemmEpilogueTraits_ = cutlass::gemm::SimplifiedGemmEpilogueTraits<
+    GemmConfig_, EpilogueFunctor_, Index_>,
+  typename GemmEpilogue_ = CustomGemmEpilogue<GemmEpilogueTraits_>,
+  typename Lambda, typename FinalLambda>
+void gemm(cublasOperation_t transA, cublasOperation_t transB, Index_ m,
+          Index_ n, Index_ k, OType alpha, IType const *A, Index_ lda,
+          IType const *B, Index_ ldb, OType beta, OType const *C, Index_ ldc,
+          OType *D, Lambda op, FinalLambda fin_op, cudaStream_t stream) {
+  baseGemm<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
+           MainLoopFunctor_, Index_, GemmConfig_, EpilogueFunctor_,
+           GemmEpilogueTraits_, GemmEpilogue_>(transA, transB, m, n, k, alpha,
+                                               A, lda, B, ldb, beta, C, ldc, D,
+                                               op, fin_op, stream);
+}
+
+/**
+  * @brief the gemm function for the case where no or simple customization is
+  * needed
+  *  It computes the following equation: D = alpha . opA(A) * opB(B) + beta . C
+  * @tparam IType input data-type (for A and B matrices)
+  * @tparam AccType accumulation data-type
+  * @tparam OType output data-type (for C and D matrices)
+  * @tparam OutputTile_ output tile size for the thread block
+  * @tparam AccumulatorsPerThread_ number of accumulators per thread
+  * @tparam Index_ index type
+  * @tparam EpilogueFunctor_ custom epilogue functor
+  * @param transA cublas transpose op for A
+  * @param transB cublas transpose op for B
+  * @param m number of rows of A and C/D
+  * @param n number of columns of B and C/D
+  * @param k number of cols of A and rows of B
+  * @param alpha scalar
+  * @param A input matrix
+  * @param lda leading dim for A
+  * @param B input matrix
+  * @param ldb leading dim for B
+  * @param beta scalar
+  * @param C input matrix
+  * @param ldc leading dim for C and D
+  * @param D output matrix
+  * @param stream cuda stream where to launch work
+  * @{
+  */
+template <
+  typename IType, typename AccType, typename OType, typename OutputTile_,
+  typename AccumulatorsPerThread_ = cutlass::Shape<8, 8, 8>,
+  typename MainLoopFunctor_ = cutlass::gemm::ThreadMultiplyAdd<
+    AccumulatorsPerThread_, cutlass::Shape<1, 4, 8>, IType, IType, AccType>,
+  typename Index_ = int,
+  typename EpilogueFunctor_ = cutlass::gemm::LinearScaling<OType>>
+void gemm(cublasOperation_t transA, cublasOperation_t transB, Index_ m,
+          Index_ n, Index_ k, OType alpha, IType const *A, Index_ lda,
+          IType const *B, Index_ ldb, OType beta, OType const *C, Index_ ldc,
+          OType *D, cudaStream_t stream) {
+  typedef CustomGemmConfig<IType, AccType, OType, OutputTile_,
+                           AccumulatorsPerThread_, MainLoopFunctor_>
+    GemmConfig_;
+  gemm<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
+       MainLoopFunctor_, Index_, GemmConfig_, EpilogueFunctor_>(
+    transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, D,
+    [](typename EpilogueFunctor_::Params &p) { return 0; },
+    0,  // missing final lambda here
+    stream);
+}
+
+}  // namespace LinAlg
+}  // namespace MLCommon
diff --git a/cpp/src_prims/linalg/cutlass_wrappers.cuh b/cpp/src_prims/linalg/cutlass_wrappers.cuh
index 060555fbc1..3ddc4bac1c 100644
--- a/cpp/src_prims/linalg/cutlass_wrappers.cuh
+++ b/cpp/src_prims/linalg/cutlass_wrappers.cuh
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cublas_v2.h>
 #include <cutlass/coord.h>
 #include <cutlass/fragment_multiply_add.h>
@@ -27,8 +26,9 @@
 #include <cutlass/gemm/linear_scaling.h>
 #include <cutlass/gemm/thread_multiply_add.h>
 #include <cutlass/util/platform.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/divide.cuh b/cpp/src_prims/linalg/divide.cuh
deleted file mode 100644
index c848ac1f4b..0000000000
--- a/cpp/src_prims/linalg/divide.cuh
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @defgroup ScalarOps Scalar operations on the input buffer
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param out the output buffer
- * @param in the input buffer
- * @param scalar the scalar used in the operations
- * @param len number of elements in the input buffer
- * @param stream cuda stream where to launch work
- * @{
- */
-template <typename math_t, typename IdxType = int>
-void divideScalar(math_t *out, const math_t *in, math_t scalar, IdxType len,
-                  cudaStream_t stream) {
-  unaryOp(
-    out, in, len, [scalar] __device__(math_t in) { return in / scalar; },
-    stream);
-}
-/** @} */
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/eig.cuh b/cpp/src_prims/linalg/eig.cuh
deleted file mode 100644
index 61f3f15228..0000000000
--- a/cpp/src_prims/linalg/eig.cuh
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <cuda_runtime_api.h>
-#include <raft/linalg/cusolver_wrappers.h>
-#include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <cuml/common/cuml_allocator.hpp>
-#include <matrix/matrix.cuh>
-#include <raft/handle.hpp>
-#include <raft/mr/device/buffer.hpp>
-
-namespace raft {
-namespace linalg {
-
-/**
- * @defgroup eig decomp with divide and conquer method for the column-major
- * symmetric matrices
- * @param handle raft handle
- * @param in the input buffer (symmetric matrix that has real eig values and
- * vectors.
- * @param n_rows: number of rows of the input
- * @param n_cols: number of cols of the input
- * @param eig_vectors: eigenvectors
- * @param eig_vals: eigen values
- * @param stream cuda stream
- * @{
- */
-template <typename math_t>
-void eigDC(const raft::handle_t &handle, const math_t *in, int n_rows,
-           int n_cols, math_t *eig_vectors, math_t *eig_vals,
-           cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  int lwork;
-  CUSOLVER_CHECK(cusolverDnsyevd_bufferSize(cusolverH, CUSOLVER_EIG_MODE_VECTOR,
-                                            CUBLAS_FILL_MODE_UPPER, n_rows, in,
-                                            n_cols, eig_vals, &lwork));
-
-  raft::mr::device::buffer<math_t> d_work(allocator, stream, lwork);
-  raft::mr::device::buffer<int> d_dev_info(allocator, stream, 1);
-
-  raft::matrix::copy(in, eig_vectors, n_rows, n_cols, stream);
-
-  CUSOLVER_CHECK(cusolverDnsyevd(cusolverH, CUSOLVER_EIG_MODE_VECTOR,
-                                 CUBLAS_FILL_MODE_UPPER, n_rows, eig_vectors,
-                                 n_cols, eig_vals, d_work.data(), lwork,
-                                 d_dev_info.data(), stream));
-  CUDA_CHECK(cudaGetLastError());
-
-  int dev_info;
-  raft::update_host(&dev_info, d_dev_info.data(), 1, stream);
-  CUDA_CHECK(cudaStreamSynchronize(stream));
-  ASSERT(dev_info == 0,
-         "eig.cuh: eigensolver couldn't converge to a solution. "
-         "This usually occurs when some of the features do not vary enough.");
-}
-
-enum EigVecMemUsage { OVERWRITE_INPUT, COPY_INPUT };
-
-#if CUDART_VERSION >= 10010
-
-/**
- * @defgroup eig decomp with divide and conquer method for the column-major
- * symmetric matrices
- * @param handle raft handle
- * @param in the input buffer (symmetric matrix that has real eig values and
- * vectors.
- * @param n_rows: number of rows of the input
- * @param n_cols: number of cols of the input
- * @param n_eig_vals: number of eigenvectors to be generated
- * @param eig_vectors: eigenvectors
- * @param eig_vals: eigen values
- * @param stream cuda stream
- * @{
- */
-template <typename math_t>
-void eigSelDC(const raft::handle_t &handle, math_t *in, int n_rows, int n_cols,
-              int n_eig_vals, math_t *eig_vectors, math_t *eig_vals,
-              EigVecMemUsage memUsage, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  int lwork;
-  int h_meig;
-
-  CUSOLVER_CHECK(cusolverDnsyevdx_bufferSize(
-    cusolverH, CUSOLVER_EIG_MODE_VECTOR, CUSOLVER_EIG_RANGE_I,
-    CUBLAS_FILL_MODE_UPPER, n_rows, in, n_cols, math_t(0.0), math_t(0.0),
-    n_cols - n_eig_vals + 1, n_cols, &h_meig, eig_vals, &lwork));
-
-  raft::mr::device::buffer<math_t> d_work(allocator, stream, lwork);
-  raft::mr::device::buffer<int> d_dev_info(allocator, stream, 1);
-  raft::mr::device::buffer<math_t> d_eig_vectors(allocator, stream, 0);
-
-  if (memUsage == OVERWRITE_INPUT) {
-    CUSOLVER_CHECK(cusolverDnsyevdx(
-      cusolverH, CUSOLVER_EIG_MODE_VECTOR, CUSOLVER_EIG_RANGE_I,
-      CUBLAS_FILL_MODE_UPPER, n_rows, in, n_cols, math_t(0.0), math_t(0.0),
-      n_cols - n_eig_vals + 1, n_cols, &h_meig, eig_vals, d_work.data(), lwork,
-      d_dev_info.data(), stream));
-  } else if (memUsage == COPY_INPUT) {
-    d_eig_vectors.resize(n_rows * n_cols, stream);
-    raft::matrix::copy(in, d_eig_vectors.data(), n_rows, n_cols, stream);
-
-    CUSOLVER_CHECK(cusolverDnsyevdx(
-      cusolverH, CUSOLVER_EIG_MODE_VECTOR, CUSOLVER_EIG_RANGE_I,
-      CUBLAS_FILL_MODE_UPPER, n_rows, eig_vectors, n_cols, math_t(0.0),
-      math_t(0.0), n_cols - n_eig_vals + 1, n_cols, &h_meig, eig_vals,
-      d_work.data(), lwork, d_dev_info.data(), stream));
-  }
-
-  CUDA_CHECK(cudaGetLastError());
-
-  int dev_info;
-  raft::update_host(&dev_info, d_dev_info.data(), 1, stream);
-  CUDA_CHECK(cudaStreamSynchronize(stream));
-  ASSERT(dev_info == 0,
-         "eig.cuh: eigensolver couldn't converge to a solution. "
-         "This usually occurs when some of the features do not vary enough.");
-
-  if (memUsage == OVERWRITE_INPUT) {
-    raft::matrix::truncZeroOrigin(in, n_rows, eig_vectors, n_rows, n_eig_vals,
-                                  stream);
-  } else if (memUsage == COPY_INPUT) {
-    raft::matrix::truncZeroOrigin(d_eig_vectors.data(), n_rows, eig_vectors,
-                                  n_rows, n_eig_vals, stream);
-  }
-}
-
-#endif
-
-/**
- * @defgroup overloaded function for eig decomp with Jacobi method for the
- * column-major symmetric matrices (in parameter)
- * @param handle: raft handle
- * @param n_rows: number of rows of the input
- * @param n_cols: number of cols of the input
- * @param eig_vectors: eigenvectors
- * @param eig_vals: eigen values
- * @param tol: error tolerance for the jacobi method. Algorithm stops when the
- * error is below tol
- * @param sweeps: number of sweeps in the Jacobi algorithm. The more the better
- * accuracy.
- * @{
- */
-template <typename math_t>
-void eigJacobi(const raft::handle_t &handle, const math_t *in, int n_rows,
-               int n_cols, math_t *eig_vectors, math_t *eig_vals,
-               cudaStream_t stream, math_t tol = 1.e-7, int sweeps = 15) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  syevjInfo_t syevj_params = nullptr;
-  CUSOLVER_CHECK(cusolverDnCreateSyevjInfo(&syevj_params));
-  CUSOLVER_CHECK(cusolverDnXsyevjSetTolerance(syevj_params, tol));
-  CUSOLVER_CHECK(cusolverDnXsyevjSetMaxSweeps(syevj_params, sweeps));
-
-  int lwork;
-  CUSOLVER_CHECK(cusolverDnsyevj_bufferSize(
-    cusolverH, CUSOLVER_EIG_MODE_VECTOR, CUBLAS_FILL_MODE_UPPER, n_rows,
-    eig_vectors, n_cols, eig_vals, &lwork, syevj_params));
-
-  raft::mr::device::buffer<math_t> d_work(allocator, stream, lwork);
-  raft::mr::device::buffer<int> dev_info(allocator, stream, 1);
-
-  raft::matrix::copy(in, eig_vectors, n_rows, n_cols, stream);
-
-  CUSOLVER_CHECK(cusolverDnsyevj(cusolverH, CUSOLVER_EIG_MODE_VECTOR,
-                                 CUBLAS_FILL_MODE_UPPER, n_rows, eig_vectors,
-                                 n_cols, eig_vals, d_work.data(), lwork,
-                                 dev_info.data(), syevj_params, stream));
-
-  int executed_sweeps;
-  CUSOLVER_CHECK(
-    cusolverDnXsyevjGetSweeps(cusolverH, syevj_params, &executed_sweeps));
-
-  CUDA_CHECK(cudaGetLastError());
-  CUSOLVER_CHECK(cusolverDnDestroySyevjInfo(syevj_params));
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/eltwise.cuh b/cpp/src_prims/linalg/eltwise.cuh
deleted file mode 100644
index a46d550220..0000000000
--- a/cpp/src_prims/linalg/eltwise.cuh
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2018, 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 "binary_op.cuh"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @defgroup ScalarOps Scalar operations on the input buffer
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param out the output buffer
- * @param in the input buffer
- * @param scalar the scalar used in the operations
- * @param len number of elements in the input buffer
- * @param stream cuda stream where to launch work
- * @{
- */
-template <typename math_t, typename IdxType = int>
-void scalarAdd(math_t *out, const math_t *in, math_t scalar, IdxType len,
-               cudaStream_t stream) {
-  raft::linalg::unaryOp(
-    out, in, len, [scalar] __device__(math_t in) { return in + scalar; },
-    stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void scalarMultiply(math_t *out, const math_t *in, math_t scalar, IdxType len,
-                    cudaStream_t stream) {
-  raft::linalg::unaryOp(
-    out, in, len, [scalar] __device__(math_t in) { return in * scalar; },
-    stream);
-}
-/** @} */
-
-/**
- * @defgroup BinaryOps Element-wise binary operations on the input buffers
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param out the output buffer
- * @param in1 the first input buffer
- * @param in2 the second input buffer
- * @param len number of elements in the input buffers
- * @param stream cuda stream where to launch work
- * @{
- */
-template <typename math_t, typename IdxType = int>
-void eltwiseAdd(math_t *out, const math_t *in1, const math_t *in2, IdxType len,
-                cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len, [] __device__(math_t a, math_t b) { return a + b; },
-    stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void eltwiseSub(math_t *out, const math_t *in1, const math_t *in2, IdxType len,
-                cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len, [] __device__(math_t a, math_t b) { return a - b; },
-    stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void eltwiseMultiply(math_t *out, const math_t *in1, const math_t *in2,
-                     IdxType len, cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len, [] __device__(math_t a, math_t b) { return a * b; },
-    stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void eltwiseDivide(math_t *out, const math_t *in1, const math_t *in2,
-                   IdxType len, cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len, [] __device__(math_t a, math_t b) { return a / b; },
-    stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void eltwiseDivideCheckZero(math_t *out, const math_t *in1, const math_t *in2,
-                            IdxType len, cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len,
-    [] __device__(math_t a, math_t b) {
-      if (b == math_t(0.0))
-        return math_t(0.0);
-      else
-        return a / b;
-    },
-    stream);
-}
-/** @} */
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/gemm.cuh b/cpp/src_prims/linalg/gemm.cuh
deleted file mode 100644
index 6bbc746ba8..0000000000
--- a/cpp/src_prims/linalg/gemm.cuh
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cublas_v2.h>
-#include <raft/linalg/cublas_wrappers.h>
-#include <cuda_utils.cuh>
-#include <raft/handle.hpp>
-#include "cutlass_wrappers.cuh"
-
-// cutlass based gemm is being kept in this namespace so that RAFT does not
-// have to take cutlass-dependency when cublas based gemm is moved to RAFT
-namespace MLCommon {
-namespace LinAlg {
-
-/**
- * @brief the gemm function for the cases with detailed epilogue customization
- *  It computes the following equation: D = alpha . opA(A) * opB(B) + beta . C
- * @tparam IType input data-type (for A and B matrices)
- * @tparam AccType accumulation data-type
- * @tparam OType output data-type (for C and D matrices)
- * @tparam OutputTile_ output tile size for the thread block
- * @tparam AccumulatorsPerThread_ number of accumulators per thread
- * @tparam MainLoopFunctor_ custom functor to be used in the main loop
- * @tparam Index_ the type of index
- * @tparam GemmConfig_ the config for the GEMM
- * @tparam EpilogueFunctor_ custom epilogue functor
- * @tparam GemmEpilogueTraits_ epilogue traits class to build the epilogue
- * @tparam GemmEpilogue_ custom epilogue
- * @tparam Lambda lambda to initialize any custom params inside EpilogueFunctor_
- * @tparam FinalLambda Final device lambda to be applied in epilogue
- * @param transA cublas transpose op for A
- * @param transB cublas transpose op for B
- * @param m number of rows of A and C/D
- * @param n number of columns of B and C/D
- * @param k number of cols of A and rows of B
- * @param alpha scalar
- * @param A input matrix
- * @param lda leading dim for A
- * @param B input matrix
- * @param ldb leading dim for B
- * @param beta scalar
- * @param C input matrix
- * @param ldc leading dim for C and D
- * @param D output matrix
- * @param op lambda function to initialize any custom params inside
- * EpilogueFunctor_
- * @param fin_op the final lambda to be run inside the Epilogue. This can help
- * in customizing a given EpilogueFunctor, without having to go through the task
- * of creating another Functor!
- * @param stream cuda stream where to launch work
- */
-template <
-  typename IType, typename AccType, typename OType, typename OutputTile_,
-  typename AccumulatorsPerThread_ = cutlass::Shape<8, 8, 8>,
-  typename MainLoopFunctor_ = cutlass::gemm::ThreadMultiplyAdd<
-    AccumulatorsPerThread_, cutlass::Shape<1, 4, 8>, IType, IType, AccType>,
-  typename Index_ = int,
-  typename GemmConfig_ =
-    CustomGemmConfig<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
-                     MainLoopFunctor_>,
-  typename EpilogueFunctor_ = LinearScaling<OType>,
-  typename GemmEpilogueTraits_ = cutlass::gemm::SimplifiedGemmEpilogueTraits<
-    GemmConfig_, EpilogueFunctor_, Index_>,
-  typename GemmEpilogue_ = CustomGemmEpilogue<GemmEpilogueTraits_>,
-  typename Lambda, typename FinalLambda>
-void gemm(cublasOperation_t transA, cublasOperation_t transB, Index_ m,
-          Index_ n, Index_ k, OType alpha, IType const *A, Index_ lda,
-          IType const *B, Index_ ldb, OType beta, OType const *C, Index_ ldc,
-          OType *D, Lambda op, FinalLambda fin_op, cudaStream_t stream) {
-  baseGemm<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
-           MainLoopFunctor_, Index_, GemmConfig_, EpilogueFunctor_,
-           GemmEpilogueTraits_, GemmEpilogue_>(transA, transB, m, n, k, alpha,
-                                               A, lda, B, ldb, beta, C, ldc, D,
-                                               op, fin_op, stream);
-}
-
-/**
- * @brief the gemm function for the case where no or simple customization is
- * needed
- *  It computes the following equation: D = alpha . opA(A) * opB(B) + beta . C
- * @tparam IType input data-type (for A and B matrices)
- * @tparam AccType accumulation data-type
- * @tparam OType output data-type (for C and D matrices)
- * @tparam OutputTile_ output tile size for the thread block
- * @tparam AccumulatorsPerThread_ number of accumulators per thread
- * @tparam Index_ index type
- * @tparam EpilogueFunctor_ custom epilogue functor
- * @param transA cublas transpose op for A
- * @param transB cublas transpose op for B
- * @param m number of rows of A and C/D
- * @param n number of columns of B and C/D
- * @param k number of cols of A and rows of B
- * @param alpha scalar
- * @param A input matrix
- * @param lda leading dim for A
- * @param B input matrix
- * @param ldb leading dim for B
- * @param beta scalar
- * @param C input matrix
- * @param ldc leading dim for C and D
- * @param D output matrix
- * @param stream cuda stream where to launch work
- * @{
- */
-template <
-  typename IType, typename AccType, typename OType, typename OutputTile_,
-  typename AccumulatorsPerThread_ = cutlass::Shape<8, 8, 8>,
-  typename MainLoopFunctor_ = cutlass::gemm::ThreadMultiplyAdd<
-    AccumulatorsPerThread_, cutlass::Shape<1, 4, 8>, IType, IType, AccType>,
-  typename Index_ = int,
-  typename EpilogueFunctor_ = cutlass::gemm::LinearScaling<OType>>
-void gemm(cublasOperation_t transA, cublasOperation_t transB, Index_ m,
-          Index_ n, Index_ k, OType alpha, IType const *A, Index_ lda,
-          IType const *B, Index_ ldb, OType beta, OType const *C, Index_ ldc,
-          OType *D, cudaStream_t stream) {
-  typedef CustomGemmConfig<IType, AccType, OType, OutputTile_,
-                           AccumulatorsPerThread_, MainLoopFunctor_>
-    GemmConfig_;
-  gemm<IType, AccType, OType, OutputTile_, AccumulatorsPerThread_,
-       MainLoopFunctor_, Index_, GemmConfig_, EpilogueFunctor_>(
-    transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, D,
-    [](typename EpilogueFunctor_::Params &p) { return 0; },
-    0,  // missing final lambda here
-    stream);
-}
-
-}  // namespace LinAlg
-}  // namespace MLCommon
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief the wrapper of cublas gemm function
- *  It computes the following equation: D = alpha . opA(A) * opB(B) + beta . C
- * @tparam math_t the type of input/output matrices
- * @param handle raft handle
- * @param a input matrix
- * @param n_rows_a number of rows of A
- * @param n_cols_a number of columns of A
- * @param b input matrix
- * @param c output matrix
- * @param n_rows_c number of rows of C
- * @param n_cols_c number of columns of C
- * @param trans_a cublas transpose op for A
- * @param trans_b cublas transpose op for B
- * @param alpha scalar
- * @param beta scalar
- * @param stream cuda stream
- */
-template <typename math_t>
-void gemm(const raft::handle_t &handle, const math_t *a, int n_rows_a,
-          int n_cols_a, const math_t *b, math_t *c, int n_rows_c, int n_cols_c,
-          cublasOperation_t trans_a, cublasOperation_t trans_b, math_t alpha,
-          math_t beta, cudaStream_t stream) {
-  cublasHandle_t cublas_h = handle.get_cublas_handle();
-
-  int m = n_rows_c;
-  int n = n_cols_c;
-  int k = trans_a == CUBLAS_OP_T ? n_rows_a : n_cols_a;
-  int lda = trans_a == CUBLAS_OP_T ? k : m;
-  int ldb = trans_b == CUBLAS_OP_T ? n : k;
-  int ldc = m;
-  CUBLAS_CHECK(cublasgemm(cublas_h, trans_a, trans_b, m, n, k, &alpha, a, lda,
-                          b, ldb, &beta, c, ldc, stream));
-}
-
-template <typename math_t>
-void gemm(const raft::handle_t &handle, const math_t *a, int n_rows_a,
-          int n_cols_a, const math_t *b, math_t *c, int n_rows_c, int n_cols_c,
-          cublasOperation_t trans_a, cublasOperation_t trans_b,
-          cudaStream_t stream) {
-  math_t alpha = math_t(1);
-  math_t beta = math_t(0);
-  gemm(handle, a, n_rows_a, n_cols_a, b, c, n_rows_c, n_cols_c, trans_a,
-       trans_b, alpha, beta, stream);
-}
-
-/**
- * @brief A wrapper for CUBLS GEMM function designed for handling all possible 
- * combinations of operand layouts.
- * It computes the following equation: Z = alpha . X * Y + beta . Z
- * @tparam T Data type of input/output matrices (float/double)
- * @param handle raft handle
- * @param z output matrix of size M rows x N columns
- * @param x input matrix of size M rows x K columns
- * @param y input matrix of size K rows x N columns
- * @param _M number of rows of X and Z
- * @param _N number of rows of Y and columns of Z
- * @param _K number of columns of X and rows of Y
- * @param isZColMajor Storage layout of Z. true = col major, false = row major
- * @param isXColMajor Storage layout of X. true = col major, false = row major
- * @param isYColMajor Storage layout of Y. true = col major, false = row major
- * @param stream cuda stream
- * @param alpha scalar
- * @param beta scalar
- */
-template <typename T>
-void gemm(const raft::handle_t &handle, T *z, T *x, T *y, int _M, int _N,
-          int _K, bool isZColMajor, bool isXColMajor, bool isYColMajor,
-          cudaStream_t stream, T alpha = T(1.0), T beta = T(0.0)) {
-  cublasHandle_t cublas_h = handle.get_cublas_handle();
-
-  cublasOperation_t trans_a, trans_b;
-  T *a, *b, *c;
-  int lda, ldb, ldc;
-  int M, N, K;
-  // This function performs c = a * b. Based on the required output layout,
-  // either a = x,  b = y or a = y, b = x. In either case c = z.
-  if (isZColMajor == true) {
-    // Result c is required in column major layout. Thus we perform,
-    // z = x * y
-    // Using BLAS call c = a * b. Therefore a = x, b = y and c = z
-
-    a = x;
-    // If x is in row major layout, cublas needs to transpose x first,
-    // therefore trans_x needs to be CUBLAS_OP_T. If x is in column major
-    // layout, trans_b needs to be CUBLAS_OP_N.
-    trans_a = isXColMajor == true ? CUBLAS_OP_N : CUBLAS_OP_T;
-    // Set leading dimension appropriately
-    lda = isXColMajor == true ? _M : _K;
-
-    b = y;
-    // If y is in row major layout, cublas needs to transpose y first,
-    // therefore trans_x needs to be CUBLAS_OP_T. If x is in column major
-    // layout, trans_b needs to be CUBLAS_OP_N.
-    trans_b = isYColMajor == true ? CUBLAS_OP_N : CUBLAS_OP_T;
-    ldb = isYColMajor == true ? _K : _N;
-
-    c = z;
-    ldc = _M;
-    M = _M;
-    N = _N;
-    K = _K;
-  } else {
-    // Result c is required in row major layout Thus we pick
-    // a = y, b = x and c = a * b = y * x
-    // cublas produces output matrix only in column major layout. To get output
-    // matrix on row major layout, we need to produce transpose of output
-    // in column major layout. Therefore we perform,
-    // tr(z) = tr(y) * tr(x)
-    // we model this using cublas call for c = a * b
-    // therefore a = tr(y), b = tr(x) and c = tr(z)
-
-    a = y;
-    // If y is in row major layout, it can be/ interpreted as tr(y) on column
-    // major layout. Therefore we can pass trans_a as CUBLAS_OP_N. If y is in
-    // column major layout, cublas needs to transpose y first, therefore
-    // trans_a needs to be CUBLAS_OP_T
-    trans_a = isYColMajor == true ? CUBLAS_OP_T : CUBLAS_OP_N;
-    // Set leading dimension appropriately
-    lda = isYColMajor == true ? _K : _N;
-
-    b = x;
-    // If x is in row major layout, it can be interpreted as tr(x) on column
-    // major layout. Therefore we can pass trans_b as CUBLAS_OP_N. If x is in
-    // column major layout, cublas needs to trasponse x first, therefore
-    // trans_b needs to be CUBLAS_OP_T
-    trans_b = isXColMajor == true ? CUBLAS_OP_T : CUBLAS_OP_N;
-    // Set leading dimension appropriately
-    ldb = isXColMajor == true ? _M : _K;
-
-    c = z;
-    ldc = _N;
-
-    M = _N;
-    N = _M;
-    K = _K;
-  }
-  // Actual cuBLAS call
-  CUBLAS_CHECK(cublasgemm(cublas_h, trans_a, trans_b, M, N, K, &alpha, a, lda,
-                          b, ldb, &beta, c, ldc, stream));
-}
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/src_prims/linalg/gemv.h b/cpp/src_prims/linalg/gemv.h
deleted file mode 100644
index c655304244..0000000000
--- a/cpp/src_prims/linalg/gemv.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cublas_v2.h>
-#include <raft/linalg/cublas_wrappers.h>
-#include <cuda_utils.cuh>
-
-#include <raft/handle.hpp>
-
-namespace raft {
-namespace linalg {
-
-template <typename math_t>
-void gemv(const raft::handle_t& handle, const math_t* a, int n_rows, int n_cols,
-          const math_t* x, int incx, math_t* y, int incy, bool trans_a,
-          math_t alpha, math_t beta, cudaStream_t stream) {
-  cublasHandle_t cublas_h = handle.get_cublas_handle();
-
-  cublasOperation_t op_a = trans_a ? CUBLAS_OP_T : CUBLAS_OP_N;
-
-  // Unfortunately there is a clash of terminology
-  // in BLAS https://docs.nvidia.com/cuda/cublas/index.html is opposite to Machine Learning
-  // In blas:
-  //  m - number of rows in input matrix
-  //  n - number of columns in input matrix
-  //  lda - purpose of it  to have ability to operate on submatrices of matrix without copying.
-  //        If you're not think about it it's always should be equal to m
-  //  lda has deal with memory layout, but has nothing with the requirement for cuBLAS perform transpose
-
-  // In Machine Learning:
-  //  m - nunmber of columns in design matrix(number of features)
-  //  n - number of rows in designed matrix (number of train examples)
-
-  int m = n_rows;
-  int n = n_cols;
-  int lda = trans_a ? m : n;
-
-  CUBLAS_CHECK(cublasgemv(cublas_h, op_a, m, n, &alpha, a, lda, x, incx, &beta,
-                          y, incy, stream));
-}
-
-template <typename math_t>
-void gemv(const raft::handle_t& handle, const math_t* a, int n_rows_a,
-          int n_cols_a, const math_t* x, math_t* y, bool trans_a, math_t alpha,
-          math_t beta, cudaStream_t stream) {
-  gemv(handle, a, n_rows_a, n_cols_a, x, 1, y, 1, trans_a, alpha, beta, stream);
-}
-
-template <typename math_t>
-void gemv(const raft::handle_t& handle, const math_t* a, int n_rows_a,
-          int n_cols_a, const math_t* x, math_t* y, bool trans_a,
-          cudaStream_t stream) {
-  math_t alpha = math_t(1);
-  math_t beta = math_t(0);
-
-  gemv(handle, a, n_rows_a, n_cols_a, x, 1, y, 1, trans_a, alpha, beta, stream);
-}
-
-};  // namespace linalg
-};  // namespace raft
diff --git a/cpp/src_prims/linalg/lstsq.cuh b/cpp/src_prims/linalg/lstsq.cuh
index fe171e5e48..0ae5fcd3ee 100644
--- a/cpp/src_prims/linalg/lstsq.cuh
+++ b/cpp/src_prims/linalg/lstsq.cuh
@@ -18,18 +18,18 @@
 
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/linalg/cusolver_wrappers.h>
+#include <raft/linalg/gemv.h>
+#include <raft/linalg/transpose.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/eig.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/qr.cuh>
+#include <raft/linalg/svd.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <raft/mr/device/buffer.hpp>
-#include <random/rng.cuh>
-#include "eig.cuh"
-#include "gemm.cuh"
-#include "gemv.h"
-#include "qr.cuh"
-#include "svd.cuh"
-#include "transpose.h"
+#include <raft/random/rng.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/map_then_reduce.cuh b/cpp/src_prims/linalg/map_then_reduce.cuh
deleted file mode 100644
index c2ba6209f9..0000000000
--- a/cpp/src_prims/linalg/map_then_reduce.cuh
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <raft/handle.hpp>
-#include <vectorized.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename Type, int TPB>
-__device__ void reduce(Type *out, const Type acc) {
-  typedef cub::BlockReduce<Type, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  Type tmp = BlockReduce(temp_storage).Sum(acc);
-  if (threadIdx.x == 0) {
-    raft::myAtomicAdd(out, tmp);
-  }
-}
-
-template <typename Type, typename MapOp, int TPB, typename... Args>
-__global__ void mapThenSumReduceKernel(Type *out, size_t len, MapOp map,
-                                       const Type *in, Args... args) {
-  Type acc = (Type)0;
-  auto idx = (threadIdx.x + (blockIdx.x * blockDim.x));
-
-  if (idx < len) {
-    acc = map(in[idx], args[idx]...);
-  }
-
-  __syncthreads();
-
-  reduce<Type, TPB>(out, acc);
-}
-
-template <typename Type, typename MapOp, int TPB, typename... Args>
-void mapThenSumReduceImpl(Type *out, size_t len, MapOp map, cudaStream_t stream,
-                          const Type *in, Args... args) {
-  CUDA_CHECK(cudaMemsetAsync(out, 0, sizeof(Type), stream));
-  const int nblks = raft::ceildiv(len, (size_t)TPB);
-  mapThenSumReduceKernel<Type, MapOp, TPB, Args...>
-    <<<nblks, TPB, 0, stream>>>(out, len, map, in, args...);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief CUDA version of map and then sum reduction operation
- * @tparam Type data-type upon which the math operation will be performed
- * @tparam MapOp the device-lambda performing the actual operation
- * @tparam TPB threads-per-block in the final kernel launched
- * @tparam Args additional parameters
- * @param out the output sum-reduced value (assumed to be a device pointer)
- * @param len number of elements in the input array
- * @param map the device-lambda
- * @param stream cuda-stream where to launch this kernel
- * @param in the input array
- * @param args additional input arrays
- */
-
-template <typename Type, typename MapOp, int TPB = 256, typename... Args>
-void mapThenSumReduce(Type *out, size_t len, MapOp map, cudaStream_t stream,
-                      const Type *in, Args... args) {
-  mapThenSumReduceImpl<Type, MapOp, TPB, Args...>(out, len, map, stream, in,
-                                                  args...);
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/matrix_vector_op.cuh b/cpp/src_prims/linalg/matrix_vector_op.cuh
deleted file mode 100644
index 610489d64d..0000000000
--- a/cpp/src_prims/linalg/matrix_vector_op.cuh
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <vectorized.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename Type, int veclen_, typename Lambda, typename IdxType>
-__global__ void matrixVectorOpKernel(Type *out, const Type *matrix,
-                                     const Type *vector, IdxType D, IdxType N,
-                                     bool rowMajor, bool bcastAlongRows,
-                                     Lambda op) {
-  typedef TxN_t<Type, veclen_> VecType;
-  IdxType len = N * D;
-  IdxType idx = threadIdx.x;
-  idx += (IdxType)blockIdx.x * (IdxType)blockDim.x;
-  idx *= VecType::Ratio;
-  if (idx >= len) return;
-  IdxType vIdx;
-  VecType mat, vec;
-  ///@todo: yikes! use fast-int-div here.
-  ///@todo: shared mem for vector could help with perf
-  if (rowMajor && bcastAlongRows) {
-    vIdx = idx % D;
-    vec.load(vector, vIdx);
-  } else if (!rowMajor && !bcastAlongRows) {
-    vIdx = idx % N;
-    vec.load(vector, vIdx);
-  } else if (rowMajor && !bcastAlongRows) {
-    vIdx = idx / D;
-    vec.fill(vector[vIdx]);
-  } else {
-    vIdx = idx / N;
-    vec.fill(vector[vIdx]);
-  }
-  mat.load(matrix, idx);
-#pragma unroll
-  for (int i = 0; i < VecType::Ratio; ++i)
-    mat.val.data[i] = op(mat.val.data[i], vec.val.data[i]);
-  mat.store(out, idx);
-}
-
-template <typename Type, int veclen_, typename Lambda, typename IdxType,
-          int TPB>
-void matrixVectorOpImpl(Type *out, const Type *matrix, const Type *vec,
-                        IdxType D, IdxType N, bool rowMajor,
-                        bool bcastAlongRows, Lambda op, cudaStream_t stream) {
-  IdxType len = N * D;
-  IdxType nblks =
-    raft::ceildiv(veclen_ ? len / veclen_ : veclen_, (IdxType)TPB);
-  matrixVectorOpKernel<Type, veclen_, Lambda, IdxType>
-    <<<nblks, TPB, 0, stream>>>(out, matrix, vec, D, N, rowMajor,
-                                bcastAlongRows, op);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief Operations for all the columns or rows with a given vector.
- * @tparam Type the matrix/vector type
- * @tparam Lambda a device function which represents a binary operator
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads per block of the cuda kernel launched
- * @param out the output matrix (passing out = matrix makes it in-place)
- * @param matrix the input matrix
- * @param vec the vector
- * @param D number of columns of matrix
- * @param N number of rows of matrix
- * @param rowMajor whether input is row or col major
- * @param bcastAlongRows whether the broadcast of vector needs to happen along
- * the rows of the matrix or columns
- * @param op the mathematical operation
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename Lambda, typename IdxType = int, int TPB = 256>
-void matrixVectorOp(Type *out, const Type *matrix, const Type *vec, IdxType D,
-                    IdxType N, bool rowMajor, bool bcastAlongRows, Lambda op,
-                    cudaStream_t stream) {
-  IdxType stride = rowMajor ? D : N;
-  size_t bytes = stride * sizeof(Type);
-  if (16 / sizeof(Type) && bytes % 16 == 0) {
-    matrixVectorOpImpl<Type, 16 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (8 / sizeof(Type) && bytes % 8 == 0) {
-    matrixVectorOpImpl<Type, 8 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (4 / sizeof(Type) && bytes % 4 == 0) {
-    matrixVectorOpImpl<Type, 4 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (2 / sizeof(Type) && bytes % 2 == 0) {
-    matrixVectorOpImpl<Type, 2 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (1 / sizeof(Type)) {
-    matrixVectorOpImpl<Type, 1 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else {
-    matrixVectorOpImpl<Type, 1, Lambda, IdxType, TPB>(
-      out, matrix, vec, D, N, rowMajor, bcastAlongRows, op, stream);
-  }
-}
-
-///@todo: come up with a cleaner interface to support these cases in future!
-
-template <typename Type, int veclen_, typename Lambda, typename IdxType>
-__global__ void matrixVectorOpKernel(Type *out, const Type *matrix,
-                                     const Type *vector1, const Type *vector2,
-                                     IdxType D, IdxType N, bool rowMajor,
-                                     bool bcastAlongRows, Lambda op) {
-  typedef TxN_t<Type, veclen_> VecType;
-  IdxType len = N * D;
-  IdxType idx = (threadIdx.x + (blockIdx.x * blockDim.x)) * VecType::Ratio;
-  if (idx >= len) return;
-  IdxType vIdx;
-  VecType mat, vec1, vec2;
-  ///@todo: yikes! use fast-int-div here.
-  ///@todo: shared mem for vector could help with perf
-  if (rowMajor && bcastAlongRows) {
-    vIdx = idx % D;
-    vec1.load(vector1, vIdx);
-    vec2.load(vector2, vIdx);
-  } else if (!rowMajor && !bcastAlongRows) {
-    vIdx = idx % N;
-    vec1.load(vector1, vIdx);
-    vec2.load(vector2, vIdx);
-  } else if (rowMajor && !bcastAlongRows) {
-    vIdx = idx / D;
-    vec1.fill(vector1[vIdx]);
-    vec2.fill(vector2[vIdx]);
-  } else {
-    vIdx = idx / N;
-    vec1.fill(vector1[vIdx]);
-    vec2.fill(vector2[vIdx]);
-  }
-  mat.load(matrix, idx);
-#pragma unroll
-  for (int i = 0; i < VecType::Ratio; ++i)
-    mat.val.data[i] = op(mat.val.data[i], vec1.val.data[i], vec2.val.data[i]);
-  mat.store(out, idx);
-}
-
-template <typename Type, int veclen_, typename Lambda, typename IdxType,
-          int TPB>
-void matrixVectorOpImpl(Type *out, const Type *matrix, const Type *vec1,
-                        const Type *vec2, IdxType D, IdxType N, bool rowMajor,
-                        bool bcastAlongRows, Lambda op, cudaStream_t stream) {
-  IdxType nblks = raft::ceildiv(N * D, (IdxType)TPB);
-  matrixVectorOpKernel<Type, veclen_, Lambda, IdxType>
-    <<<nblks, TPB, 0, stream>>>(out, matrix, vec1, vec2, D, N, rowMajor,
-                                bcastAlongRows, op);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief Operations for all the columns or rows with the given vectors.
- * @tparam Type the matrix/vector type
- * @tparam Lambda a device function which represents a binary operator
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads per block of the cuda kernel launched
- * @param out the output matrix (passing out = matrix makes it in-place)
- * @param matrix the input matrix
- * @param vec1 the first vector
- * @param vec2 the second vector
- * @param D number of columns of matrix
- * @param N number of rows of matrix
- * @param rowMajor whether input is row or col major
- * @param bcastAlongRows whether the broadcast of vector needs to happen along
- * the rows of the matrix or columns
- * @param op the mathematical operation
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename Lambda, typename IdxType = int, int TPB = 256>
-void matrixVectorOp(Type *out, const Type *matrix, const Type *vec1,
-                    const Type *vec2, IdxType D, IdxType N, bool rowMajor,
-                    bool bcastAlongRows, Lambda op, cudaStream_t stream) {
-  IdxType stride = rowMajor ? D : N;
-  size_t bytes = stride * sizeof(Type);
-  if (16 / sizeof(Type) && bytes % 16 == 0) {
-    matrixVectorOpImpl<Type, 16 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (8 / sizeof(Type) && bytes % 8 == 0) {
-    matrixVectorOpImpl<Type, 8 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (4 / sizeof(Type) && bytes % 4 == 0) {
-    matrixVectorOpImpl<Type, 4 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (2 / sizeof(Type) && bytes % 2 == 0) {
-    matrixVectorOpImpl<Type, 2 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else if (1 / sizeof(Type)) {
-    matrixVectorOpImpl<Type, 1 / sizeof(Type), Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  } else {
-    matrixVectorOpImpl<Type, 1, Lambda, IdxType, TPB>(
-      out, matrix, vec1, vec2, D, N, rowMajor, bcastAlongRows, op, stream);
-  }
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/mean_squared_error.cuh b/cpp/src_prims/linalg/mean_squared_error.cuh
deleted file mode 100644
index 9d1538c172..0000000000
--- a/cpp/src_prims/linalg/mean_squared_error.cuh
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2018, 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 "map_then_reduce.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief CUDA version mean squared error function mean((A-B)**2)
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam TPB threads-per-block 
- * @param out the output mean squared error value (assumed to be a device pointer)
- * @param A input array (assumed to be a device pointer)
- * @param B input array (assumed to be a device pointer)
- * @param len number of elements in the input arrays
- * @param weight weight to apply to every term in the mean squared error calculation
- * @param stream cuda-stream where to launch this kernel
- */
-template <typename math_t, int TPB = 256>
-void meanSquaredError(math_t* out, const math_t* A, const math_t* B, size_t len,
-                      math_t weight, cudaStream_t stream) {
-  auto sq_diff = [len, weight] __device__(const math_t a, const math_t b) {
-    math_t diff = a - b;
-    return diff * diff * weight / len;
-  };
-  mapThenSumReduce<math_t, decltype(sq_diff), TPB>(out, len, sq_diff, stream, A,
-                                                   B);
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/multiply.cuh b/cpp/src_prims/linalg/multiply.cuh
deleted file mode 100644
index ce948c927d..0000000000
--- a/cpp/src_prims/linalg/multiply.cuh
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @defgroup ScalarOps Scalar operations on the input buffer
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param out the output buffer
- * @param in the input buffer
- * @param scalar the scalar used in the operations
- * @param len number of elements in the input buffer
- * @param stream cuda stream where to launch work
- * @{
- */
-template <typename math_t, typename IdxType = int>
-void multiplyScalar(math_t *out, const math_t *in, math_t scalar, IdxType len,
-                    cudaStream_t stream) {
-  unaryOp(
-    out, in, len, [scalar] __device__(math_t in) { return in * scalar; },
-    stream);
-}
-/** @} */
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/norm.cuh b/cpp/src_prims/linalg/norm.cuh
deleted file mode 100644
index 64930a7123..0000000000
--- a/cpp/src_prims/linalg/norm.cuh
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 "reduce.cuh"
-
-namespace raft {
-namespace linalg {
-
-/** different types of norms supported on the input buffers */
-enum NormType { L1Norm = 0, L2Norm };
-
-/**
- * @brief Compute row-wise norm of the input matrix and perform fin_op lambda
- *
- * Row-wise norm is useful while computing pairwise distance matrix, for
- * example.
- * This is used in many clustering algos like knn, kmeans, dbscan, etc... The
- * current implementation is optimized only for bigger values of 'D'.
- *
- * @tparam Type the data type
- * @tparam Lambda device final lambda
- * @tparam IdxType Integer type used to for addressing
- * @param dots the output vector of row-wise dot products
- * @param data the input matrix (currently assumed to be row-major)
- * @param D number of columns of data
- * @param N number of rows of data
- * @param type the type of norm to be applied
- * @param rowMajor whether the input is row-major or not
- * @param stream cuda stream where to launch work
- * @param fin_op the final lambda op
- */
-template <typename Type, typename IdxType = int,
-          typename Lambda = raft::Nop<Type, IdxType>>
-void rowNorm(Type *dots, const Type *data, IdxType D, IdxType N, NormType type,
-             bool rowMajor, cudaStream_t stream,
-             Lambda fin_op = raft::Nop<Type, IdxType>()) {
-  switch (type) {
-    case L1Norm:
-      reduce(dots, data, D, N, (Type)0, rowMajor, true, stream, false,
-             raft::L1Op<Type, IdxType>(), raft::Sum<Type>(), fin_op);
-      break;
-    case L2Norm:
-      reduce(dots, data, D, N, (Type)0, rowMajor, true, stream, false,
-             raft::L2Op<Type>(), raft::Sum<Type>(), fin_op);
-      break;
-    default:
-      ASSERT(false, "Invalid norm type passed! [%d]", type);
-  };
-}
-
-/**
- * @brief Compute column-wise norm of the input matrix and perform fin_op
- * @tparam Type the data type
- * @tparam Lambda device final lambda
- * @tparam IdxType Integer type used to for addressing
- * @param dots the output vector of column-wise dot products
- * @param data the input matrix (currently assumed to be row-major)
- * @param D number of columns of data
- * @param N number of rows of data
- * @param type the type of norm to be applied
- * @param rowMajor whether the input is row-major or not
- * @param stream cuda stream where to launch work
- * @param fin_op the final lambda op
- */
-template <typename Type, typename IdxType = int,
-          typename Lambda = raft::Nop<Type, IdxType>>
-void colNorm(Type *dots, const Type *data, IdxType D, IdxType N, NormType type,
-             bool rowMajor, cudaStream_t stream,
-             Lambda fin_op = raft::Nop<Type, IdxType>()) {
-  switch (type) {
-    case L1Norm:
-      reduce(dots, data, D, N, (Type)0, rowMajor, false, stream, false,
-             raft::L1Op<Type, IdxType>(), raft::Sum<Type>(), fin_op);
-      break;
-    case L2Norm:
-      reduce(dots, data, D, N, (Type)0, rowMajor, false, stream, false,
-             raft::L2Op<Type, IdxType>(), raft::Sum<Type>(), fin_op);
-      break;
-    default:
-      ASSERT(false, "Invalid norm type passed! [%d]", type);
-  };
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/power.cuh b/cpp/src_prims/linalg/power.cuh
index ab1c5d4353..7a60f6c7ba 100644
--- a/cpp/src_prims/linalg/power.cuh
+++ b/cpp/src_prims/linalg/power.cuh
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include "binary_op.cuh"
-#include "unary_op.cuh"
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/qr.cuh b/cpp/src_prims/linalg/qr.cuh
deleted file mode 100644
index 233f2f98f6..0000000000
--- a/cpp/src_prims/linalg/qr.cuh
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2018-2019, 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 <raft/linalg/cublas_wrappers.h>
-#include <raft/linalg/cusolver_wrappers.h>
-#include <common/device_buffer.hpp>
-#include <cuml/common/cuml_allocator.hpp>
-#include <matrix/matrix.cuh>
-#include <raft/mr/device/buffer.hpp>
-
-namespace raft {
-namespace linalg {
-
-/**
- * @defgroup QRdecomp QR decomposition
- * @{
- */
-
-/**
- * @brief compute QR decomp and return only Q matrix
- * @param handle: raft handle
- * @param M: input matrix
- * @param Q: Q matrix to be returned (on GPU)
- * @param n_rows: number rows of input matrix
- * @param n_cols: number columns of input matrix
- * @param stream cuda stream
- * @{
- */
-template <typename math_t>
-void qrGetQ(const raft::handle_t &handle, const math_t *M, math_t *Q,
-            int n_rows, int n_cols, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  int m = n_rows, n = n_cols;
-  int k = min(m, n);
-  CUDA_CHECK(cudaMemcpyAsync(Q, M, sizeof(math_t) * m * n,
-                             cudaMemcpyDeviceToDevice, stream));
-
-  raft::mr::device::buffer<math_t> tau(allocator, stream, k);
-  CUDA_CHECK(cudaMemsetAsync(tau.data(), 0, sizeof(math_t) * k, stream));
-
-  raft::mr::device::buffer<int> devInfo(allocator, stream, 1);
-  int Lwork;
-
-  CUSOLVER_CHECK(cusolverDngeqrf_bufferSize(cusolverH, m, n, Q, m, &Lwork));
-  raft::mr::device::buffer<math_t> workspace(allocator, stream, Lwork);
-  CUSOLVER_CHECK(cusolverDngeqrf(cusolverH, m, n, Q, m, tau.data(),
-                                 workspace.data(), Lwork, devInfo.data(),
-                                 stream));
-  /// @note in v9.2, without deviceSynchronize *SquareMatrixNorm* ml-prims unit-tests fail.
-#if defined(CUDART_VERSION) && CUDART_VERSION <= 9020
-  CUDA_CHECK(cudaDeviceSynchronize());
-#endif
-  CUSOLVER_CHECK(
-    cusolverDnorgqr_bufferSize(cusolverH, m, n, k, Q, m, tau.data(), &Lwork));
-  workspace.resize(Lwork, stream);
-  CUSOLVER_CHECK(cusolverDnorgqr(cusolverH, m, n, k, Q, m, tau.data(),
-                                 workspace.data(), Lwork, devInfo.data(),
-                                 stream));
-}
-
-/**
- * @brief compute QR decomp and return both Q and R matrices
- * @param handle: raft handle
- * @param M: input matrix
- * @param Q: Q matrix to be returned (on GPU)
- * @param R: R matrix to be returned (on GPU)
- * @param n_rows: number rows of input matrix
- * @param n_cols: number columns of input matrix
- * @param stream cuda stream
- */
-template <typename math_t>
-void qrGetQR(const raft::handle_t &handle, math_t *M, math_t *Q, math_t *R,
-             int n_rows, int n_cols, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  int m = n_rows, n = n_cols;
-  raft::mr::device::buffer<math_t> R_full(allocator, stream, m * n);
-  raft::mr::device::buffer<math_t> tau(allocator, stream, min(m, n));
-  CUDA_CHECK(
-    cudaMemsetAsync(tau.data(), 0, sizeof(math_t) * min(m, n), stream));
-  int R_full_nrows = m, R_full_ncols = n;
-  CUDA_CHECK(cudaMemcpyAsync(R_full.data(), M, sizeof(math_t) * m * n,
-                             cudaMemcpyDeviceToDevice, stream));
-
-  int Lwork;
-  raft::mr::device::buffer<int> devInfo(allocator, stream, 1);
-
-  CUSOLVER_CHECK(cusolverDngeqrf_bufferSize(cusolverH, R_full_nrows,
-                                            R_full_ncols, R_full.data(),
-                                            R_full_nrows, &Lwork));
-  raft::mr::device::buffer<math_t> workspace(allocator, stream, Lwork);
-  CUSOLVER_CHECK(cusolverDngeqrf(
-    cusolverH, R_full_nrows, R_full_ncols, R_full.data(), R_full_nrows,
-    tau.data(), workspace.data(), Lwork, devInfo.data(), stream));
-  // @note in v9.2, without deviceSynchronize *SquareMatrixNorm* ml-prims unit-tests fail.
-#if defined(CUDART_VERSION) && CUDART_VERSION <= 9020
-  CUDA_CHECK(cudaDeviceSynchronize());
-#endif
-
-  raft::matrix::copyUpperTriangular(R_full.data(), R, m, n, stream);
-
-  CUDA_CHECK(cudaMemcpyAsync(Q, R_full.data(), sizeof(math_t) * m * n,
-                             cudaMemcpyDeviceToDevice, stream));
-  int Q_nrows = m, Q_ncols = n;
-
-  CUSOLVER_CHECK(cusolverDnorgqr_bufferSize(cusolverH, Q_nrows, Q_ncols,
-                                            min(Q_ncols, Q_nrows), Q, Q_nrows,
-                                            tau.data(), &Lwork));
-  workspace.resize(Lwork, stream);
-  CUSOLVER_CHECK(cusolverDnorgqr(
-    cusolverH, Q_nrows, Q_ncols, min(Q_ncols, Q_nrows), Q, Q_nrows, tau.data(),
-    workspace.data(), Lwork, devInfo.data(), stream));
-}
-/** @} */
-
-};  // namespace linalg
-};  // namespace raft
diff --git a/cpp/src_prims/linalg/reduce.cuh b/cpp/src_prims/linalg/reduce.cuh
deleted file mode 100644
index 6dcc35580b..0000000000
--- a/cpp/src_prims/linalg/reduce.cuh
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <cuda_utils.cuh>
-#include "coalesced_reduction.cuh"
-#include "strided_reduction.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief Compute reduction of the input matrix along the requested dimension
- *
- * @tparam InType the data type of the input
- * @tparam OutType the data type of the output (as well as the data type for
- *  which reduction is performed)
- * @tparam IdxType data type of the indices of the array
- * @tparam MainLambda Unary lambda applied while acculumation (eg: L1 or L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*MainLambda)(InType, IdxType);</pre>
- * @tparam ReduceLambda Binary lambda applied for reduction (eg: addition(+) for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*ReduceLambda)(OutType);</pre>
- * @tparam FinalLambda the final lambda applied before STG (eg: Sqrt for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*FinalLambda)(OutType);</pre>
- * @param dots the output reduction vector
- * @param data the input matrix
- * @param D number of columns
- * @param N number of rows
- * @param init initial value to use for the reduction
- * @param rowMajor input matrix is row-major or not
- * @param alongRows whether to reduce along rows or columns
- * @param stream cuda stream where to launch work
- * @param inplace reduction result added inplace or overwrites old values?
- * @param main_op elementwise operation to apply before reduction
- * @param reduce_op binary reduction operation
- * @param final_op elementwise operation to apply before storing results
- */
-template <typename InType, typename OutType = InType, typename IdxType = int,
-          typename MainLambda = raft::Nop<InType, IdxType>,
-          typename ReduceLambda = raft::Sum<OutType>,
-          typename FinalLambda = raft::Nop<OutType>>
-void reduce(OutType *dots, const InType *data, int D, int N, OutType init,
-            bool rowMajor, bool alongRows, cudaStream_t stream,
-            bool inplace = false,
-            MainLambda main_op = raft::Nop<InType, IdxType>(),
-            ReduceLambda reduce_op = raft::Sum<OutType>(),
-            FinalLambda final_op = raft::Nop<OutType>()) {
-  if (rowMajor && alongRows) {
-    coalescedReduction(dots, data, D, N, init, stream, inplace, main_op,
-                       reduce_op, final_op);
-  } else if (rowMajor && !alongRows) {
-    stridedReduction(dots, data, D, N, init, stream, inplace, main_op,
-                     reduce_op, final_op);
-  } else if (!rowMajor && alongRows) {
-    stridedReduction(dots, data, N, D, init, stream, inplace, main_op,
-                     reduce_op, final_op);
-  } else {
-    coalescedReduction(dots, data, N, D, init, stream, inplace, main_op,
-                       reduce_op, final_op);
-  }
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/reduce_cols_by_key.cuh b/cpp/src_prims/linalg/reduce_cols_by_key.cuh
index 3ccc88cd14..e103b1d4ea 100644
--- a/cpp/src_prims/linalg/reduce_cols_by_key.cuh
+++ b/cpp/src_prims/linalg/reduce_cols_by_key.cuh
@@ -18,8 +18,8 @@
 
 #include <stdlib.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/reduce_rows_by_key.cuh b/cpp/src_prims/linalg/reduce_rows_by_key.cuh
index b93aae7d4b..480dc0986d 100644
--- a/cpp/src_prims/linalg/reduce_rows_by_key.cuh
+++ b/cpp/src_prims/linalg/reduce_rows_by_key.cuh
@@ -20,8 +20,8 @@
 
 #include <stdlib.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/rsvd.cuh b/cpp/src_prims/linalg/rsvd.cuh
index 58e37a6460..bdca7243a1 100644
--- a/cpp/src_prims/linalg/rsvd.cuh
+++ b/cpp/src_prims/linalg/rsvd.cuh
@@ -16,18 +16,20 @@
 
 #pragma once
 
+#include <common/device_buffer.hpp>
+
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/linalg/cusolver_wrappers.h>
-#include <cuda_utils.cuh>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/linalg/transpose.h>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/eig.cuh>
+#include <raft/linalg/gemm.cuh>
+#include <raft/linalg/qr.cuh>
+#include <raft/linalg/svd.cuh>
+#include <raft/matrix/math.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <raft/mr/device/buffer.hpp>
-#include <random/rng.cuh>
-#include "eig.cuh"
-#include "gemm.cuh"
-#include "qr.cuh"
-#include "svd.cuh"
-#include "transpose.h"
+#include <raft/random/rng.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/sqrt.cuh b/cpp/src_prims/linalg/sqrt.cuh
index 4f7542dc12..92a05f7797 100644
--- a/cpp/src_prims/linalg/sqrt.cuh
+++ b/cpp/src_prims/linalg/sqrt.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include "unary_op.cuh"
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/strided_reduction.cuh b/cpp/src_prims/linalg/strided_reduction.cuh
deleted file mode 100644
index 0a62ade86a..0000000000
--- a/cpp/src_prims/linalg/strided_reduction.cuh
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <type_traits>
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-// Kernel to perform reductions along the strided dimension
-// of the matrix, i.e. reduce along columns for row major or reduce along rows
-// for column major layout
-template <typename Type, typename MainLambda>
-__global__ void stridedSummationKernel(Type *dots, const Type *data, int D,
-                                       int N, Type init, MainLambda main_op) {
-  // Thread reduction
-  Type thread_data = Type(init);
-  int colStart = blockIdx.x * blockDim.x + threadIdx.x;
-  if (colStart < D) {
-    int rowStart = blockIdx.y * blockDim.y + threadIdx.y;
-    int stride = blockDim.y * gridDim.y;
-    for (int j = rowStart; j < N; j += stride) {
-      int idx = colStart + j * D;
-      thread_data += main_op(data[idx], j);
-    }
-  }
-
-  // Block reduction
-  extern __shared__ char tmp[];  // One element per thread in block
-  Type *temp = (Type *)tmp;      // Cast to desired type
-  int myidx = threadIdx.x + blockDim.x * threadIdx.y;
-  temp[myidx] = thread_data;
-  __syncthreads();
-  for (int j = blockDim.y / 2; j > 0; j /= 2) {
-    if (threadIdx.y < j) temp[myidx] += temp[myidx + j * blockDim.x];
-    __syncthreads();
-  }
-
-  // Grid reduction
-  if ((colStart < D) && (threadIdx.y == 0))
-    raft::myAtomicAdd(dots + colStart, temp[myidx]);
-}
-
-// Kernel to perform reductions along the strided dimension
-// of the matrix, i.e. reduce along columns for row major or reduce along rows
-// for column major layout
-template <typename InType, typename OutType, typename IdxType,
-          typename MainLambda, typename ReduceLambda>
-__global__ void stridedReductionKernel(OutType *dots, const InType *data, int D,
-                                       int N, OutType init, MainLambda main_op,
-                                       ReduceLambda reduce_op) {
-  // Thread reduction
-  OutType thread_data = init;
-  IdxType colStart = blockIdx.x * blockDim.x + threadIdx.x;
-  if (colStart < D) {
-    IdxType rowStart = blockIdx.y * blockDim.y + threadIdx.y;
-    IdxType stride = blockDim.y * gridDim.y;
-    for (IdxType j = rowStart; j < N; j += stride) {
-      IdxType idx = colStart + j * D;
-      thread_data = reduce_op(thread_data, main_op(data[idx], j));
-    }
-  }
-
-  // Block reduction
-  extern __shared__ char tmp[];  // One element per thread in block
-  auto *temp = (OutType *)tmp;   // Cast to desired type
-  IdxType myidx = threadIdx.x + ((IdxType)blockDim.x * (IdxType)threadIdx.y);
-  temp[myidx] = thread_data;
-  __syncthreads();
-  for (int j = blockDim.y / 2; j > 0; j /= 2) {
-    if (threadIdx.y < j)
-      temp[myidx] = reduce_op(temp[myidx], temp[myidx + j * blockDim.x]);
-    __syncthreads();
-  }
-
-  // Grid reduction
-  if ((colStart < D) && (threadIdx.y == 0))
-    raft::myAtomicReduce(dots + colStart, temp[myidx], reduce_op);
-}
-
-/**
- * @brief Compute reduction of the input matrix along the strided dimension
- *
- * @tparam InType the data type of the input
- * @tparam OutType the data type of the output (as well as the data type for
- *  which reduction is performed)
- * @tparam IdxType data type of the indices of the array
- * @tparam MainLambda Unary lambda applied while acculumation (eg: L1 or L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*MainLambda)(InType, IdxType);</pre>
- * @tparam ReduceLambda Binary lambda applied for reduction (eg: addition(+) for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*ReduceLambda)(OutType);</pre>
- * @tparam FinalLambda the final lambda applied before STG (eg: Sqrt for L2 norm)
- * It must be a 'callable' supporting the following input and output:
- * <pre>OutType (*FinalLambda)(OutType);</pre>
- * @param dots the output reduction vector
- * @param data the input matrix
- * @param D leading dimension of data
- * @param N second dimension data
- * @param init initial value to use for the reduction
- * @param main_op elementwise operation to apply before reduction
- * @param reduce_op binary reduction operation
- * @param final_op elementwise operation to apply before storing results
- * @param inplace reduction result added inplace or overwrites old values?
- * @param stream cuda stream where to launch work
- */
-template <typename InType, typename OutType = InType, typename IdxType = int,
-          typename MainLambda = raft::Nop<InType, IdxType>,
-          typename ReduceLambda = raft::Sum<OutType>,
-          typename FinalLambda = raft::Nop<OutType>>
-void stridedReduction(OutType *dots, const InType *data, IdxType D, IdxType N,
-                      OutType init, cudaStream_t stream, bool inplace = false,
-                      MainLambda main_op = raft::Nop<InType, IdxType>(),
-                      ReduceLambda reduce_op = raft::Sum<OutType>(),
-                      FinalLambda final_op = raft::Nop<OutType>()) {
-  ///@todo: this extra should go away once we have eliminated the need
-  /// for atomics in stridedKernel (redesign for this is already underway)
-  if (!inplace)
-    raft::linalg::unaryOp(
-      dots, dots, D, [init] __device__(OutType a) { return init; }, stream);
-
-  // Arbitrary numbers for now, probably need to tune
-  const dim3 thrds(32, 16);
-  IdxType elemsPerThread = raft::ceildiv(N, (IdxType)thrds.y);
-  elemsPerThread = (elemsPerThread > 8) ? 8 : elemsPerThread;
-  const dim3 nblks(raft::ceildiv(D, (IdxType)thrds.x),
-                   raft::ceildiv(N, (IdxType)thrds.y * elemsPerThread));
-  const size_t shmemSize = sizeof(OutType) * thrds.x * thrds.y;
-
-  ///@todo: this complication should go away once we have eliminated the need
-  /// for atomics in stridedKernel (redesign for this is already underway)
-  if (std::is_same<ReduceLambda, raft::Sum<OutType>>::value &&
-      std::is_same<InType, OutType>::value)
-    stridedSummationKernel<InType>
-      <<<nblks, thrds, shmemSize, stream>>>(dots, data, D, N, init, main_op);
-  else
-    stridedReductionKernel<InType, OutType, IdxType>
-      <<<nblks, thrds, shmemSize, stream>>>(dots, data, D, N, init, main_op,
-                                            reduce_op);
-
-  ///@todo: this complication should go away once we have eliminated the need
-  /// for atomics in stridedKernel (redesign for this is already underway)
-  // Perform final op on output data
-  if (!std::is_same<FinalLambda, raft::Nop<OutType>>::value)
-    raft::linalg::unaryOp(dots, dots, D, final_op, stream);
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/subtract.cuh b/cpp/src_prims/linalg/subtract.cuh
deleted file mode 100644
index 115e17d323..0000000000
--- a/cpp/src_prims/linalg/subtract.cuh
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include "binary_op.cuh"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief Elementwise scalar subtraction operation on the input buffer
- *
- * @tparam InT     input data-type. Also the data-type upon which the math ops
- *                 will be performed
- * @tparam OutT    output data-type
- * @tparam IdxType Integer type used to for addressing
- *
- * @param out    the output buffer
- * @param in     the input buffer
- * @param scalar the scalar used in the operations
- * @param len    number of elements in the input buffer
- * @param stream cuda stream where to launch work
- */
-template <typename InT, typename OutT = InT, typename IdxType = int>
-void subtractScalar(OutT *out, const InT *in, InT scalar, IdxType len,
-                    cudaStream_t stream) {
-  auto op = [scalar] __device__(InT in) { return OutT(in - scalar); };
-  unaryOp<InT, decltype(op), IdxType, OutT>(out, in, len, op, stream);
-}
-
-/**
- * @brief Elementwise subtraction operation on the input buffers
- * @tparam InT     input data-type. Also the data-type upon which the math ops
- *                 will be performed
- * @tparam OutT    output data-type
- * @tparam IdxType Integer type used to for addressing
- *
- * @param out    the output buffer
- * @param in1    the first input buffer
- * @param in2    the second input buffer
- * @param len    number of elements in the input buffers
- * @param stream cuda stream where to launch work
- */
-template <typename InT, typename OutT = InT, typename IdxType = int>
-void subtract(OutT *out, const InT *in1, const InT *in2, IdxType len,
-              cudaStream_t stream) {
-  auto op = [] __device__(InT a, InT b) { return OutT(a - b); };
-  binaryOp<InT, decltype(op), OutT, IdxType>(out, in1, in2, len, op, stream);
-}
-
-template <class math_t, typename IdxType>
-__global__ void subtract_dev_scalar_kernel(math_t *outDev, const math_t *inDev,
-                                           const math_t *singleScalarDev,
-                                           IdxType len) {
-  //TODO: kernel do not use shared memory in current implementation
-  int i = ((IdxType)blockIdx.x * (IdxType)blockDim.x) + threadIdx.x;
-  if (i < len) {
-    outDev[i] = inDev[i] - *singleScalarDev;
-  }
-}
-
-/** Substract single value pointed by singleScalarDev parameter in device memory from inDev[i] and write result to outDev[i]
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param outDev the output buffer
- * @param inDev the input buffer
- * @param singleScalarDev pointer to the scalar located in device memory
- * @param len number of elements in the input and output buffer
- * @param stream cuda stream
- * @remark block size has not been tuned
- */
-template <typename math_t, typename IdxType = int, int TPB = 256>
-void subtractDevScalar(math_t *outDev, const math_t *inDev,
-                       const math_t *singleScalarDev, IdxType len,
-                       cudaStream_t stream) {
-  // Just for the note - there is no way to express such operation with cuBLAS in effective way
-  // https://stackoverflow.com/questions/14051064/add-scalar-to-vector-in-blas-cublas-cuda
-  const IdxType nblks = raft::ceildiv(len, (IdxType)TPB);
-  subtract_dev_scalar_kernel<math_t>
-    <<<nblks, TPB, 0, stream>>>(outDev, inDev, singleScalarDev, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/svd.cuh b/cpp/src_prims/linalg/svd.cuh
deleted file mode 100644
index feacc73f3f..0000000000
--- a/cpp/src_prims/linalg/svd.cuh
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <raft/linalg/cublas_wrappers.h>
-#include <raft/linalg/cusolver_wrappers.h>
-#include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
-#include <cuml/common/cuml_allocator.hpp>
-#include <matrix/math.cuh>
-#include <matrix/matrix.cuh>
-#include <raft/handle.hpp>
-#include <raft/mr/device/buffer.hpp>
-#include "eig.cuh"
-#include "gemm.cuh"
-#include "transpose.h"
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief singular value decomposition (SVD) on the column major float type
- * input matrix using QR method
- * @param handle: raft handle
- * @param in: input matrix
- * @param n_rows: number rows of input matrix
- * @param n_cols: number columns of input matrix
- * @param sing_vals: singular values of input matrix
- * @param left_sing_vecs: left singular values of input matrix
- * @param right_sing_vecs: right singular values of input matrix
- * @param trans_right: transpose right vectors or not
- * @param gen_left_vec: generate left eig vector. Not activated.
- * @param gen_right_vec: generate right eig vector. Not activated.
- * @param stream cuda stream
- */
-// TODO: activate gen_left_vec and gen_right_vec options
-// TODO: couldn't template this function due to cusolverDnSgesvd and
-// cusolverSnSgesvd. Check if there is any other way.
-template <typename T>
-void svdQR(const raft::handle_t &handle, T *in, int n_rows, int n_cols,
-           T *sing_vals, T *left_sing_vecs, T *right_sing_vecs,
-           bool trans_right, bool gen_left_vec, bool gen_right_vec,
-           cudaStream_t stream) {
-  std::shared_ptr<raft::mr::device::allocator> allocator =
-    handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-  cublasHandle_t cublasH = handle.get_cublas_handle();
-
-#if CUDART_VERSION >= 10010
-  // 46340: sqrt of max int value
-  ASSERT(n_rows <= 46340,
-         "svd solver is not supported for the data that has more than 46340 "
-         "samples (rows) "
-         "if you are using CUDA version 10.1. Please use other solvers such as "
-         "eig if it is available.");
-#endif
-
-  const int m = n_rows;
-  const int n = n_cols;
-
-  raft::mr::device::buffer<int> devInfo(allocator, stream, 1);
-  T *d_rwork = nullptr;
-
-  int lwork = 0;
-  CUSOLVER_CHECK(
-    cusolverDngesvd_bufferSize<T>(cusolverH, n_rows, n_cols, &lwork));
-  raft::mr::device::buffer<T> d_work(allocator, stream, lwork);
-
-  char jobu = 'S';
-  char jobvt = 'A';
-
-  if (!gen_left_vec) {
-    char new_u = 'N';
-    strcpy(&jobu, &new_u);
-  }
-
-  if (!gen_right_vec) {
-    char new_vt = 'N';
-    strcpy(&jobvt, &new_vt);
-  }
-
-  CUSOLVER_CHECK(cusolverDngesvd(
-    cusolverH, jobu, jobvt, m, n, in, m, sing_vals, left_sing_vecs, m,
-    right_sing_vecs, n, d_work.data(), lwork, d_rwork, devInfo.data(), stream));
-
-  // Transpose the right singular vector back
-  if (trans_right) raft::linalg::transpose(right_sing_vecs, n_cols, stream);
-
-  CUDA_CHECK(cudaGetLastError());
-
-  int dev_info;
-  raft::update_host(&dev_info, devInfo.data(), 1, stream);
-  CUDA_CHECK(cudaStreamSynchronize(stream));
-  ASSERT(dev_info == 0,
-         "svd.cuh: svd couldn't converge to a solution. "
-         "This usually occurs when some of the features do not vary enough.");
-}
-
-template <typename T>
-void svdEig(const raft::handle_t &handle, T *in, int n_rows, int n_cols, T *S,
-            T *U, T *V, bool gen_left_vec, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-  cublasHandle_t cublasH = handle.get_cublas_handle();
-
-  int len = n_cols * n_cols;
-  raft::mr::device::buffer<T> in_cross_mult(allocator, stream, len);
-
-  T alpha = T(1);
-  T beta = T(0);
-  raft::linalg::gemm(handle, in, n_rows, n_cols, in, in_cross_mult.data(),
-                     n_cols, n_cols, CUBLAS_OP_T, CUBLAS_OP_N, alpha, beta,
-                     stream);
-
-  eigDC(handle, in_cross_mult.data(), n_cols, n_cols, V, S, stream);
-
-  raft::matrix::colReverse(V, n_cols, n_cols, stream);
-  raft::matrix::rowReverse(S, n_cols, 1, stream);
-
-  raft::matrix::seqRoot(S, S, alpha, n_cols, stream, true);
-
-  if (gen_left_vec) {
-    raft::linalg::gemm(handle, in, n_rows, n_cols, V, U, n_rows, n_cols,
-                       CUBLAS_OP_N, CUBLAS_OP_N, alpha, beta, stream);
-    raft::matrix::matrixVectorBinaryDivSkipZero(U, S, n_rows, n_cols, false,
-                                                true, stream);
-  }
-}
-
-/**
- * @brief on the column major input matrix using Jacobi method
- * @param handle: raft handle
- * @param in: input matrix
- * @param n_rows: number rows of input matrix
- * @param n_cols: number columns of input matrix
- * @param sing_vals: singular values of input matrix
- * @param left_sing_vecs: left singular vectors of input matrix
- * @param right_sing_vecs: right singular vectors of input matrix
- * @param gen_left_vec: generate left eig vector. Not activated.
- * @param gen_right_vec: generate right eig vector. Not activated.
- * @param tol: error tolerance for the jacobi method. Algorithm stops when the
- * error is below tol
- * @param max_sweeps: number of sweeps in the Jacobi algorithm. The more the better
- * accuracy.
- * @param stream cuda stream
- */
-template <typename math_t>
-void svdJacobi(const raft::handle_t &handle, math_t *in, int n_rows, int n_cols,
-               math_t *sing_vals, math_t *left_sing_vecs,
-               math_t *right_sing_vecs, bool gen_left_vec, bool gen_right_vec,
-               math_t tol, int max_sweeps, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cusolverDnHandle_t cusolverH = handle.get_cusolver_dn_handle();
-
-  gesvdjInfo_t gesvdj_params = NULL;
-
-  CUSOLVER_CHECK(cusolverDnCreateGesvdjInfo(&gesvdj_params));
-  CUSOLVER_CHECK(cusolverDnXgesvdjSetTolerance(gesvdj_params, tol));
-  CUSOLVER_CHECK(cusolverDnXgesvdjSetMaxSweeps(gesvdj_params, max_sweeps));
-
-  int m = n_rows;
-  int n = n_cols;
-
-  raft::mr::device::buffer<int> devInfo(allocator, stream, 1);
-
-  int lwork = 0;
-  int econ = 1;
-
-  CUSOLVER_CHECK(raft::linalg::cusolverDngesvdj_bufferSize(
-    cusolverH, CUSOLVER_EIG_MODE_VECTOR, econ, m, n, in, m, sing_vals,
-    left_sing_vecs, m, right_sing_vecs, n, &lwork, gesvdj_params));
-
-  raft::mr::device::buffer<math_t> d_work(allocator, stream, lwork);
-
-  CUSOLVER_CHECK(raft::linalg::cusolverDngesvdj(
-    cusolverH, CUSOLVER_EIG_MODE_VECTOR, econ, m, n, in, m, sing_vals,
-    left_sing_vecs, m, right_sing_vecs, n, d_work.data(), lwork, devInfo.data(),
-    gesvdj_params, stream));
-
-  CUSOLVER_CHECK(cusolverDnDestroyGesvdjInfo(gesvdj_params));
-}
-
-/**
- * @brief reconstruct a matrix use left and right singular vectors and
- * singular values
- * @param handle: raft handle
- * @param U: left singular vectors of size n_rows x k
- * @param S: square matrix with singular values on its diagonal, k x k
- * @param V: right singular vectors of size n_cols x k
- * @param out: reconstructed matrix to be returned
- * @param n_rows: number rows of output matrix
- * @param n_cols: number columns of output matrix
- * @param k: number of singular values
- * @param stream cuda stream
- */
-template <typename math_t>
-void svdReconstruction(const raft::handle_t &handle, math_t *U, math_t *S,
-                       math_t *V, math_t *out, int n_rows, int n_cols, int k,
-                       cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-
-  const math_t alpha = 1.0, beta = 0.0;
-  raft::mr::device::buffer<math_t> SVT(allocator, stream, k * n_cols);
-
-  raft::linalg::gemm(handle, S, k, k, V, SVT.data(), k, n_cols, CUBLAS_OP_N,
-                     CUBLAS_OP_T, alpha, beta, stream);
-  raft::linalg::gemm(handle, U, n_rows, k, SVT.data(), out, n_rows, n_cols,
-                     CUBLAS_OP_N, CUBLAS_OP_N, alpha, beta, stream);
-}
-
-/**
- * @brief reconstruct a matrix use left and right singular vectors and
- * singular values
- * @param handle: raft handle
- * @param A_d: input matrix
- * @param U: left singular vectors of size n_rows x k
- * @param S_vec: singular values as a vector
- * @param V: right singular vectors of size n_cols x k
- * @param n_rows: number rows of output matrix
- * @param n_cols: number columns of output matrix
- * @param k: number of singular values to be computed, 1.0 for normal SVD
- * @param tol: tolerance for the evaluation
- * @param stream cuda stream
- */
-template <typename math_t>
-bool evaluateSVDByL2Norm(const raft::handle_t &handle, math_t *A_d, math_t *U,
-                         math_t *S_vec, math_t *V, int n_rows, int n_cols,
-                         int k, math_t tol, cudaStream_t stream) {
-  auto allocator = handle.get_device_allocator();
-  cublasHandle_t cublasH = handle.get_cublas_handle();
-
-  int m = n_rows, n = n_cols;
-
-  // form product matrix
-  raft::mr::device::buffer<math_t> P_d(allocator, stream, m * n);
-  raft::mr::device::buffer<math_t> S_mat(allocator, stream, k * k);
-  CUDA_CHECK(cudaMemsetAsync(P_d.data(), 0, sizeof(math_t) * m * n, stream));
-  CUDA_CHECK(cudaMemsetAsync(S_mat.data(), 0, sizeof(math_t) * k * k, stream));
-
-  raft::matrix::initializeDiagonalMatrix(S_vec, S_mat.data(), k, k, stream);
-  svdReconstruction(handle, U, S_mat.data(), V, P_d.data(), m, n, k, stream);
-
-  // get norms of each
-  math_t normA = raft::matrix::getL2Norm(handle, A_d, m * n, stream);
-  math_t normU = raft::matrix::getL2Norm(handle, U, m * k, stream);
-  math_t normS = raft::matrix::getL2Norm(handle, S_mat.data(), k * k, stream);
-  math_t normV = raft::matrix::getL2Norm(handle, V, n * k, stream);
-  math_t normP = raft::matrix::getL2Norm(handle, P_d.data(), m * n, stream);
-
-  // calculate percent error
-  const math_t alpha = 1.0, beta = -1.0;
-  raft::mr::device::buffer<math_t> A_minus_P(allocator, stream, m * n);
-  CUDA_CHECK(
-    cudaMemsetAsync(A_minus_P.data(), 0, sizeof(math_t) * m * n, stream));
-
-  CUBLAS_CHECK(raft::linalg::cublasgeam(cublasH, CUBLAS_OP_N, CUBLAS_OP_N, m, n,
-                                        &alpha, A_d, m, &beta, P_d.data(), m,
-                                        A_minus_P.data(), m, stream));
-
-  math_t norm_A_minus_P =
-    raft::matrix::getL2Norm(handle, A_minus_P.data(), m * n, stream);
-  math_t percent_error = 100.0 * norm_A_minus_P / normA;
-  return (percent_error / 100.0 < tol);
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/ternary_op.cuh b/cpp/src_prims/linalg/ternary_op.cuh
index 8f152d523b..6062598e5e 100644
--- a/cpp/src_prims/linalg/ternary_op.cuh
+++ b/cpp/src_prims/linalg/ternary_op.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <vectorized.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/vectorized.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/src_prims/linalg/transpose.h b/cpp/src_prims/linalg/transpose.h
deleted file mode 100644
index d90f6271fa..0000000000
--- a/cpp/src_prims/linalg/transpose.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2020, 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 <raft/linalg/cublas_wrappers.h>
-#include <thrust/device_vector.h>
-#include <raft/handle.hpp>
-
-namespace raft {
-namespace linalg {
-
-/**
- * @brief transpose on the column major input matrix using Jacobi method
- * @param handle: raft handle
- * @param in: input matrix
- * @param out: output. Transposed input matrix
- * @param n_rows: number rows of input matrix
- * @param n_cols: number columns of input matrix
- * @param stream: cuda stream
- */
-template <typename math_t>
-void transpose(const raft::handle_t &handle, math_t *in, math_t *out,
-               int n_rows, int n_cols, cudaStream_t stream) {
-  cublasHandle_t cublas_h = handle.get_cublas_handle();
-
-  int out_n_rows = n_cols;
-  int out_n_cols = n_rows;
-
-  const math_t alpha = 1.0;
-  const math_t beta = 0.0;
-  CUBLAS_CHECK(raft::linalg::cublasgeam(
-    cublas_h, CUBLAS_OP_T, CUBLAS_OP_N, out_n_rows, out_n_cols, &alpha, in,
-    n_rows, &beta, out, out_n_rows, out, out_n_rows, stream));
-}
-
-/**
- * @brief transpose on the column major input matrix using Jacobi method
- * @param inout: input and output matrix
- * @param n: number of rows and columns of input matrix
- * @param stream: cuda stream
- */
-template <typename math_t>
-void transpose(math_t *inout, int n, cudaStream_t stream) {
-  auto m = n;
-  auto size = n * n;
-  auto d_inout = inout;
-  auto counting = thrust::make_counting_iterator<int>(0);
-
-  thrust::for_each(thrust::cuda::par.on(stream), counting, counting + size,
-                   [=] __device__(int idx) {
-                     int s_row = idx % m;
-                     int s_col = idx / m;
-                     int d_row = s_col;
-                     int d_col = s_row;
-                     if (s_row < s_col) {
-                       auto temp = d_inout[d_col * m + d_row];
-                       d_inout[d_col * m + d_row] = d_inout[s_col * m + s_row];
-                       d_inout[s_col * m + s_row] = temp;
-                     }
-                   });
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/linalg/unary_op.cuh b/cpp/src_prims/linalg/unary_op.cuh
deleted file mode 100644
index 85c4675026..0000000000
--- a/cpp/src_prims/linalg/unary_op.cuh
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <vectorized.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename InType, int VecLen, typename Lambda, typename OutType,
-          typename IdxType>
-__global__ void unaryOpKernel(OutType *out, const InType *in, IdxType len,
-                              Lambda op) {
-  typedef TxN_t<InType, VecLen> InVecType;
-  typedef TxN_t<OutType, VecLen> OutVecType;
-  InVecType a;
-  OutVecType b;
-  IdxType idx = threadIdx.x + ((IdxType)blockIdx.x * blockDim.x);
-  idx *= InVecType::Ratio;
-  if (idx >= len) return;
-  a.load(in, idx);
-#pragma unroll
-  for (int i = 0; i < InVecType::Ratio; ++i) {
-    b.val.data[i] = op(a.val.data[i]);
-  }
-  b.store(out, idx);
-}
-
-template <typename InType, int VecLen, typename Lambda, typename OutType,
-          typename IdxType, int TPB>
-void unaryOpImpl(OutType *out, const InType *in, IdxType len, Lambda op,
-                 cudaStream_t stream) {
-  const IdxType nblks =
-    raft::ceildiv(VecLen ? len / VecLen : len, (IdxType)TPB);
-  unaryOpKernel<InType, VecLen, Lambda, OutType, IdxType>
-    <<<nblks, TPB, 0, stream>>>(out, in, len, op);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief perform element-wise unary operation in the input array
- * @tparam InType input data-type
- * @tparam Lambda the device-lambda performing the actual operation
- * @tparam OutType output data-type
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads-per-block in the final kernel launched
- * @param out the output array
- * @param in the input array
- * @param len number of elements in the input array
- * @param op the device-lambda
- * @param stream cuda stream where to launch work
- * @note Lambda must be a functor with the following signature:
- *       `OutType func(const InType& val);`
- */
-template <typename InType, typename Lambda, typename IdxType = int,
-          typename OutType = InType, int TPB = 256>
-void unaryOp(OutType *out, const InType *in, IdxType len, Lambda op,
-             cudaStream_t stream) {
-  if (len <= 0) return;  //silently skip in case of 0 length input
-  constexpr auto maxSize =
-    sizeof(InType) >= sizeof(OutType) ? sizeof(InType) : sizeof(OutType);
-  size_t bytes = len * maxSize;
-  uint64_t inAddr = uint64_t(in);
-  uint64_t outAddr = uint64_t(out);
-  if (16 / maxSize && bytes % 16 == 0 && inAddr % 16 == 0 &&
-      outAddr % 16 == 0) {
-    unaryOpImpl<InType, 16 / maxSize, Lambda, OutType, IdxType, TPB>(
-      out, in, len, op, stream);
-  } else if (8 / maxSize && bytes % 8 == 0 && inAddr % 8 == 0 &&
-             outAddr % 8 == 0) {
-    unaryOpImpl<InType, 8 / maxSize, Lambda, OutType, IdxType, TPB>(
-      out, in, len, op, stream);
-  } else if (4 / maxSize && bytes % 4 == 0 && inAddr % 4 == 0 &&
-             outAddr % 4 == 0) {
-    unaryOpImpl<InType, 4 / maxSize, Lambda, OutType, IdxType, TPB>(
-      out, in, len, op, stream);
-  } else if (2 / maxSize && bytes % 2 == 0 && inAddr % 2 == 0 &&
-             outAddr % 2 == 0) {
-    unaryOpImpl<InType, 2 / maxSize, Lambda, OutType, IdxType, TPB>(
-      out, in, len, op, stream);
-  } else if (1 / maxSize) {
-    unaryOpImpl<InType, 1 / maxSize, Lambda, OutType, IdxType, TPB>(
-      out, in, len, op, stream);
-  } else {
-    unaryOpImpl<InType, 1, Lambda, OutType, IdxType, TPB>(out, in, len, op,
-                                                          stream);
-  }
-}
-
-template <typename OutType, typename Lambda, typename IdxType>
-__global__ void writeOnlyUnaryOpKernel(OutType *out, IdxType len, Lambda op) {
-  IdxType idx = threadIdx.x + ((IdxType)blockIdx.x * blockDim.x);
-  if (idx < len) {
-    op(out + idx, idx);
-  }
-}
-
-/**
- * @brief Perform an element-wise unary operation into the output array
- *
- * Compared to `unaryOp()`, this method does not do any reads from any inputs
- *
- * @tparam OutType output data-type
- * @tparam Lambda  the device-lambda performing the actual operation
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB     threads-per-block in the final kernel launched
- *
- * @param[out] out    the output array [on device] [len = len]
- * @param[in]  len    number of elements in the input array
- * @param[in]  op     the device-lambda which must be of the form:
- *                    `void func(OutType* outLocationOffset, IdxType idx);`
- *                    where outLocationOffset will be out + idx.
- * @param[in]  stream cuda stream where to launch work
- */
-template <typename OutType, typename Lambda, typename IdxType = int,
-          int TPB = 256>
-void writeOnlyUnaryOp(OutType *out, IdxType len, Lambda op,
-                      cudaStream_t stream) {
-  if (len <= 0) return;  // silently skip in case of 0 length input
-  auto nblks = raft::ceildiv<IdxType>(len, TPB);
-  writeOnlyUnaryOpKernel<OutType, Lambda, IdxType>
-    <<<nblks, TPB, 0, stream>>>(out, len, op);
-  CUDA_CHECK(cudaGetLastError());
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/src_prims/matrix/grammatrix.cuh b/cpp/src_prims/matrix/grammatrix.cuh
index 9dc8581e16..b107affc58 100644
--- a/cpp/src_prims/matrix/grammatrix.cuh
+++ b/cpp/src_prims/matrix/grammatrix.cuh
@@ -18,7 +18,7 @@
 
 #include <raft/linalg/cublas_wrappers.h>
 #include <distance/distance.cuh>
-#include <linalg/gemm.cuh>
+#include <raft/linalg/gemm.cuh>
 
 namespace MLCommon {
 namespace Matrix {
diff --git a/cpp/src_prims/matrix/kernelfactory.cuh b/cpp/src_prims/matrix/kernelfactory.cuh
index e83acf29fb..d7600365e5 100644
--- a/cpp/src_prims/matrix/kernelfactory.cuh
+++ b/cpp/src_prims/matrix/kernelfactory.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cuml/matrix/kernelparams.h>
+#include <raft/cudart_utils.h>
 #include "grammatrix.cuh"
 #include "kernelmatrices.cuh"
 
diff --git a/cpp/src_prims/matrix/kernelmatrices.cuh b/cpp/src_prims/matrix/kernelmatrices.cuh
index 07b037fa1d..e80ad5b3eb 100644
--- a/cpp/src_prims/matrix/kernelmatrices.cuh
+++ b/cpp/src_prims/matrix/kernelmatrices.cuh
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
 #include <distance/distance.cuh>
-#include <linalg/gemm.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/gemm.cuh>
 #include "grammatrix.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/matrix/math.cuh b/cpp/src_prims/matrix/math.cuh
deleted file mode 100644
index b77ee1968f..0000000000
--- a/cpp/src_prims/matrix/math.cuh
+++ /dev/null
@@ -1,497 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/unary_op.cuh>
-#include <raft/handle.hpp>
-#include <raft/mr/device/allocator.hpp>
-#include <raft/mr/device/buffer.hpp>
-
-namespace raft {
-namespace matrix {
-
-/**
- * @defgroup MatrixMathOp math operation on the input matrix
- * @{
- */
-
-/**
- * @brief Power of every element in the input matrix
- * @param in: input matrix
- * @param out: output matrix. The result is stored in the out matrix
- * @param scalar: every element is multiplied with scalar.
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t>
-void power(math_t *in, math_t *out, math_t scalar, int len,
-           cudaStream_t stream) {
-  auto d_src = in;
-  auto d_dest = out;
-
-  raft::linalg::binaryOp(
-    d_dest, d_src, d_src, len,
-    [=] __device__(math_t a, math_t b) { return scalar * a * b; }, stream);
-}
-
-/**
- * @brief Power of every element in the input matrix
- * @param inout: input matrix and also the result is stored
- * @param scalar: every element is multiplied with scalar.
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t>
-void power(math_t *inout, math_t scalar, int len, cudaStream_t stream) {
-  power(inout, inout, scalar, len, stream);
-}
-
-/**
- * @brief Power of every element in the input matrix
- * @param inout: input matrix and also the result is stored
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t>
-void power(math_t *inout, int len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  power(inout, scalar, len, stream);
-}
-
-/**
- * @brief Power of every element in the input matrix
- * @param in: input matrix
- * @param out: output matrix. The result is stored in the out matrix
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @{
- */
-template <typename math_t>
-void power(math_t *in, math_t *out, int len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  power(in, out, scalar, len, stream);
-}
-
-/**
- * @brief Square root of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param in: input matrix and also the result is stored
- * @param out: output matrix. The result is stored in the out matrix
- * @param scalar: every element is multiplied with scalar
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @param set_neg_zero whether to set negative numbers to zero
- */
-template <typename math_t, typename IdxType = int>
-void seqRoot(math_t *in, math_t *out, math_t scalar, IdxType len,
-             cudaStream_t stream, bool set_neg_zero = false) {
-  auto d_src = in;
-  auto d_dest = out;
-
-  raft::linalg::unaryOp(
-    d_dest, d_src, len,
-    [=] __device__(math_t a) {
-      if (set_neg_zero) {
-        if (a < math_t(0)) {
-          return math_t(0);
-        } else {
-          return sqrt(a * scalar);
-        }
-      } else {
-        return sqrt(a * scalar);
-      }
-    },
-    stream);
-}
-
-/**
- * @brief Square root of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param inout: input matrix and also the result is stored
- * @param scalar: every element is multiplied with scalar
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @param set_neg_zero whether to set negative numbers to zero
- */
-template <typename math_t, typename IdxType = int>
-void seqRoot(math_t *inout, math_t scalar, IdxType len, cudaStream_t stream,
-             bool set_neg_zero = false) {
-  seqRoot(inout, inout, scalar, len, stream, set_neg_zero);
-}
-
-/**
- * @brief Square root of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param in: input matrix and also the result is stored
- * @param out: output matrix. The result is stored in the out matrix
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t, typename IdxType = int>
-void seqRoot(math_t *in, math_t *out, IdxType len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  seqRoot(in, out, scalar, len, stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void seqRoot(math_t *inout, IdxType len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  seqRoot(inout, inout, scalar, len, stream);
-}
-
-template <typename math_t, typename IdxType = int>
-void setSmallValuesZero(math_t *out, const math_t *in, IdxType len,
-                        cudaStream_t stream, math_t thres = 1e-15) {
-  raft::linalg::unaryOp(
-    out, in, len,
-    [=] __device__(math_t a) {
-      if (a <= thres && -a <= thres) {
-        return math_t(0);
-      } else {
-        return a;
-      }
-    },
-    stream);
-}
-
-/**
- * @brief sets the small values to zero based on a defined threshold
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param inout: input matrix and also the result is stored
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @param thres: threshold
- */
-template <typename math_t, typename IdxType = int>
-void setSmallValuesZero(math_t *inout, IdxType len, cudaStream_t stream,
-                        math_t thres = 1e-15) {
-  setSmallValuesZero(inout, inout, len, stream, thres);
-}
-
-/**
- * @brief Reciprocal of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param in: input matrix and also the result is stored
- * @param out: output matrix. The result is stored in the out matrix
- * @param scalar: every element is multiplied with scalar
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @param setzero round down to zero if the input is less the threshold
- * @param thres the threshold used to forcibly set inputs to zero
- * @{
- */
-template <typename math_t, typename IdxType = int>
-void reciprocal(math_t *in, math_t *out, math_t scalar, int len,
-                cudaStream_t stream, bool setzero = false,
-                math_t thres = 1e-15) {
-  auto d_src = in;
-  auto d_dest = out;
-
-  raft::linalg::unaryOp(
-    d_dest, d_src, len,
-    [=] __device__(math_t a) {
-      if (setzero) {
-        if (abs(a) <= thres) {
-          return math_t(0);
-        } else {
-          return scalar / a;
-        }
-      } else {
-        return scalar / a;
-      }
-    },
-    stream);
-}
-
-/**
- * @brief Reciprocal of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param inout: input matrix and also the result is stored
- * @param scalar: every element is multiplied with scalar
- * @param len: number elements of input matrix
- * @param stream cuda stream
- * @param setzero: (default false) when true and |value|<thres, avoid dividing by (almost) zero
- * @param thres: Threshold to avoid dividing by zero (|value| < thres -> result = 0)
- */
-template <typename math_t, typename IdxType = int>
-void reciprocal(math_t *inout, math_t scalar, IdxType len, cudaStream_t stream,
-                bool setzero = false, math_t thres = 1e-15) {
-  reciprocal(inout, inout, scalar, len, stream, setzero, thres);
-}
-
-/**
- * @brief Reciprocal of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param inout: input matrix and also the result is stored
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t, typename IdxType = int>
-void reciprocal(math_t *inout, IdxType len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  reciprocal(inout, scalar, len, stream);
-}
-
-/**
- * @brief Reciprocal of every element in the input matrix
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param in: input matrix and also the result is stored
- * @param out: output matrix. The result is stored in the out matrix
- * @param len: number elements of input matrix
- * @param stream cuda stream
- */
-template <typename math_t, typename IdxType = int>
-void reciprocal(math_t *in, math_t *out, IdxType len, cudaStream_t stream) {
-  math_t scalar = 1.0;
-  reciprocal(in, out, scalar, len, stream);
-}
-
-template <typename math_t>
-void setValue(math_t *out, const math_t *in, math_t scalar, int len,
-              cudaStream_t stream = 0) {
-  raft::linalg::unaryOp(
-    out, in, len, [scalar] __device__(math_t in) { return scalar; }, stream);
-}
-
-/**
- * @brief ratio of every element over sum of input vector is calculated
- * @tparam math_t data-type upon which the math operation will be performed
- * @tparam IdxType Integer type used to for addressing
- * @param src: input matrix
- * @param dest: output matrix. The result is stored in the dest matrix
- * @param len: number elements of input matrix
- * @param allocator device allocator
- * @param stream cuda stream
- */
-template <typename math_t, typename IdxType = int>
-void ratio(const raft::handle_t &handle, math_t *src, math_t *dest, IdxType len,
-           cudaStream_t stream) {
-  auto d_src = src;
-  auto d_dest = dest;
-
-  std::shared_ptr<raft::mr::device::allocator> allocator =
-    handle.get_device_allocator();
-
-  raft::mr::device::buffer<math_t> d_sum(allocator, stream, 1);
-  auto *d_sum_ptr = d_sum.data();
-  auto no_op = [] __device__(math_t in) { return in; };
-  raft::linalg::mapThenSumReduce(d_sum_ptr, len, no_op, stream, src);
-  raft::linalg::unaryOp(
-    d_dest, d_src, len, [=] __device__(math_t a) { return a / (*d_sum_ptr); },
-    stream);
-}
-
-/** @} */
-
-// Computes the argmax(d_in) column-wise in a DxN matrix
-template <typename T, int TPB>
-__global__ void argmaxKernel(const T *d_in, int D, int N, T *argmax) {
-  typedef cub::BlockReduce<cub::KeyValuePair<int, T>, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-
-  // compute maxIndex=argMax  index for column
-  using KVP = cub::KeyValuePair<int, T>;
-  int rowStart = blockIdx.x * D;
-  KVP thread_data(-1, -raft::myInf<T>());
-
-  for (int i = threadIdx.x; i < D; i += TPB) {
-    int idx = rowStart + i;
-    thread_data = cub::ArgMax()(thread_data, KVP(i, d_in[idx]));
-  }
-
-  auto maxKV = BlockReduce(temp_storage).Reduce(thread_data, cub::ArgMax());
-
-  if (threadIdx.x == 0) {
-    argmax[blockIdx.x] = maxKV.key;
-  }
-}
-
-/**
- * @brief Argmax: find the row idx with maximum value for each column
- * @param in: input matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param out: output vector of size n_cols
- * @param stream: cuda stream
- */
-template <typename math_t>
-void argmax(const math_t *in, int n_rows, int n_cols, math_t *out,
-            cudaStream_t stream) {
-  int D = n_rows;
-  int N = n_cols;
-  if (D <= 32) {
-    argmaxKernel<math_t, 32><<<N, 32, 0, stream>>>(in, D, N, out);
-  } else if (D <= 64) {
-    argmaxKernel<math_t, 64><<<N, 64, 0, stream>>>(in, D, N, out);
-  } else if (D <= 128) {
-    argmaxKernel<math_t, 128><<<N, 128, 0, stream>>>(in, D, N, out);
-  } else {
-    argmaxKernel<math_t, 256><<<N, 256, 0, stream>>>(in, D, N, out);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-// Utility kernel needed for signFlip.
-// Computes the argmax(abs(d_in)) column-wise in a DxN matrix followed by
-// flipping the sign if the |max| value for each column is negative.
-template <typename T, int TPB>
-__global__ void signFlipKernel(T *d_in, int D, int N) {
-  typedef cub::BlockReduce<cub::KeyValuePair<int, T>, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-
-  // compute maxIndex=argMax (with abs()) index for column
-  using KVP = cub::KeyValuePair<int, T>;
-  int rowStart = blockIdx.x * D;
-  KVP thread_data(0, 0);
-  for (int i = threadIdx.x; i < D; i += TPB) {
-    int idx = rowStart + i;
-    thread_data = cub::ArgMax()(thread_data, KVP(idx, abs(d_in[idx])));
-  }
-  auto maxKV = BlockReduce(temp_storage).Reduce(thread_data, cub::ArgMax());
-
-  // flip column sign if d_in[maxIndex] < 0
-  __shared__ bool need_sign_flip;
-  if (threadIdx.x == 0) {
-    need_sign_flip = d_in[maxKV.key] < T(0);
-  }
-  __syncthreads();
-
-  if (need_sign_flip) {
-    for (int i = threadIdx.x; i < D; i += TPB) {
-      int idx = rowStart + i;
-      d_in[idx] = -d_in[idx];
-    }
-  }
-}
-
-/**
- * @brief sign flip for PCA. This is used to stabilize the sign of column
- * major eigen vectors. Flips the sign if the column has negative |max|.
- * @param inout: input matrix. Result also stored in this parameter
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param stream cuda stream
- */
-template <typename math_t>
-void signFlip(math_t *inout, int n_rows, int n_cols, cudaStream_t stream) {
-  int D = n_rows;
-  int N = n_cols;
-  auto data = inout;
-  if (D <= 32) {
-    signFlipKernel<math_t, 32><<<N, 32, 0, stream>>>(data, D, N);
-  } else if (D <= 64) {
-    signFlipKernel<math_t, 64><<<N, 64, 0, stream>>>(data, D, N);
-  } else if (D <= 128) {
-    signFlipKernel<math_t, 128><<<N, 128, 0, stream>>>(data, D, N);
-  } else {
-    signFlipKernel<math_t, 256><<<N, 256, 0, stream>>>(data, D, N);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinaryMult(Type *data, const Type *vec, IdxType n_row,
-                            IdxType n_col, bool rowMajor, bool bcastAlongRows,
-                            cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a * b; }, stream);
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinaryMultSkipZero(Type *data, const Type *vec, IdxType n_row,
-                                    IdxType n_col, bool rowMajor,
-                                    bool bcastAlongRows, cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) {
-      if (b == Type(0))
-        return a;
-      else
-        return a * b;
-    },
-    stream);
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinaryDiv(Type *data, const Type *vec, IdxType n_row,
-                           IdxType n_col, bool rowMajor, bool bcastAlongRows,
-                           cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a / b; }, stream);
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinaryDivSkipZero(Type *data, const Type *vec, IdxType n_row,
-                                   IdxType n_col, bool rowMajor,
-                                   bool bcastAlongRows, cudaStream_t stream,
-                                   bool return_zero = false) {
-  if (return_zero) {
-    raft::linalg::matrixVectorOp(
-      data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-      [] __device__(Type a, Type b) {
-        if (raft::myAbs(b) < Type(1e-10))
-          return Type(0);
-        else
-          return a / b;
-      },
-      stream);
-  } else {
-    raft::linalg::matrixVectorOp(
-      data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-      [] __device__(Type a, Type b) {
-        if (raft::myAbs(b) < Type(1e-10))
-          return a;
-        else
-          return a / b;
-      },
-      stream);
-  }
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinaryAdd(Type *data, const Type *vec, IdxType n_row,
-                           IdxType n_col, bool rowMajor, bool bcastAlongRows,
-                           cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a + b; }, stream);
-}
-
-template <typename Type, typename IdxType = int, int TPB = 256>
-void matrixVectorBinarySub(Type *data, const Type *vec, IdxType n_row,
-                           IdxType n_col, bool rowMajor, bool bcastAlongRows,
-                           cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    data, data, vec, n_col, n_row, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a - b; }, stream);
-}
-
-};  // end namespace matrix
-};  // end namespace raft
diff --git a/cpp/src_prims/matrix/matrix.cuh b/cpp/src_prims/matrix/matrix.cuh
deleted file mode 100644
index 6d687bfcb8..0000000000
--- a/cpp/src_prims/matrix/matrix.cuh
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <cuda_runtime.h>
-#include <cusolverDn.h>
-#include <raft/linalg/cublas_wrappers.h>
-#include <thrust/device_vector.h>
-#include <thrust/execution_policy.h>
-#include <algorithm>
-#include <cstddef>
-#include <cuda_utils.cuh>
-#include <raft/handle.hpp>
-
-namespace raft {
-namespace matrix {
-
-using namespace std;
-
-/**
- * @brief Copy selected rows of the input matrix into contiguous space.
- *
- * On exit out[i + k*n_rows] = in[indices[i] + k*n_rows],
- * where i = 0..n_rows_indices-1, and k = 0..n_cols-1.
- *
- * @param in input matrix
- * @param n_rows number of rows of output matrix
- * @param n_cols number of columns of output matrix
- * @param out output matrix
- * @param indices of the rows to be copied
- * @param n_rows_indices number of rows to copy
- * @param stream cuda stream
- * @param rowMajor whether the matrix has row major layout
- */
-template <typename m_t>
-void copyRows(const m_t *in, int n_rows, int n_cols, m_t *out,
-              const int *indices, int n_rows_indices, cudaStream_t stream,
-              bool rowMajor = false) {
-  if (rowMajor) {
-    ASSERT(false, "matrix.h: row major is not supported yet!");
-  }
-
-  auto size = n_rows_indices * n_cols;
-  auto counting = thrust::make_counting_iterator<int>(0);
-
-  thrust::for_each(thrust::cuda::par.on(stream), counting, counting + size,
-                   [=] __device__(int idx) {
-                     int row = idx % n_rows_indices;
-                     int col = idx / n_rows_indices;
-
-                     out[col * n_rows_indices + row] =
-                       in[col * n_rows + indices[row]];
-                   });
-}
-
-/**
- * @brief copy matrix operation for column major matrices.
- * @param in: input matrix
- * @param out: output matrix
- * @param n_rows: number of rows of output matrix
- * @param n_cols: number of columns of output matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void copy(const m_t *in, m_t *out, int n_rows, int n_cols,
-          cudaStream_t stream) {
-  raft::copy_async(out, in, n_rows * n_cols, stream);
-}
-
-/**
- * @brief copy matrix operation for column major matrices. First n_rows and
- * n_cols of input matrix "in" is copied to "out" matrix.
- * @param in: input matrix
- * @param in_n_rows: number of rows of input matrix
- * @param out: output matrix
- * @param out_n_rows: number of rows of output matrix
- * @param out_n_cols: number of columns of output matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void truncZeroOrigin(m_t *in, int in_n_rows, m_t *out, int out_n_rows,
-                     int out_n_cols, cudaStream_t stream) {
-  auto m = out_n_rows;
-  auto k = in_n_rows;
-  auto size = out_n_rows * out_n_cols;
-  auto d_q = in;
-  auto d_q_trunc = out;
-  auto counting = thrust::make_counting_iterator<int>(0);
-
-  thrust::for_each(thrust::cuda::par.on(stream), counting, counting + size,
-                   [=] __device__(int idx) {
-                     int row = idx % m;
-                     int col = idx / m;
-                     d_q_trunc[col * m + row] = d_q[col * k + row];
-                   });
-}
-
-/**
- * @brief Columns of a column major matrix is reversed (i.e. first column and
- * last column are swapped)
- * @param inout: input and output matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void colReverse(m_t *inout, int n_rows, int n_cols, cudaStream_t stream) {
-  auto n = n_cols;
-  auto m = n_rows;
-  auto size = n_rows * n_cols;
-  auto d_q = inout;
-  auto d_q_reversed = inout;
-  auto counting = thrust::make_counting_iterator<int>(0);
-
-  thrust::for_each(thrust::cuda::par.on(stream), counting,
-                   counting + (size / 2), [=] __device__(int idx) {
-                     int dest_row = idx % m;
-                     int dest_col = idx / m;
-                     int src_row = dest_row;
-                     int src_col = (n - dest_col) - 1;
-                     m_t temp = (m_t)d_q_reversed[idx];
-                     d_q_reversed[idx] = d_q[src_col * m + src_row];
-                     d_q[src_col * m + src_row] = temp;
-                   });
-}
-
-/**
- * @brief Rows of a column major matrix is reversed (i.e. first row and last
- * row are swapped)
- * @param inout: input and output matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void rowReverse(m_t *inout, int n_rows, int n_cols, cudaStream_t stream) {
-  auto m = n_rows;
-  auto size = n_rows * n_cols;
-  auto d_q = inout;
-  auto d_q_reversed = inout;
-  auto counting = thrust::make_counting_iterator<int>(0);
-
-  thrust::for_each(thrust::cuda::par.on(stream), counting,
-                   counting + (size / 2), [=] __device__(int idx) {
-                     int dest_row = idx % m;
-                     int dest_col = idx / m;
-                     int src_row = (m - dest_row) - 1;
-                     ;
-                     int src_col = dest_col;
-
-                     m_t temp = (m_t)d_q_reversed[idx];
-                     d_q_reversed[idx] = d_q[src_col * m + src_row];
-                     d_q[src_col * m + src_row] = temp;
-                   });
-}
-
-/**
- * @brief Prints the data stored in GPU memory
- * @param in: input matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param h_separator: horizontal separator character
- * @param v_separator: vertical separator character
- */
-template <typename m_t>
-void print(const m_t *in, int n_rows, int n_cols, char h_separator = ' ',
-           char v_separator = '\n') {
-  std::vector<m_t> h_matrix = std::vector<m_t>(n_cols * n_rows);
-  CUDA_CHECK(cudaMemcpy(h_matrix.data(), in, n_cols * n_rows * sizeof(m_t),
-                        cudaMemcpyDeviceToHost));
-
-  for (auto i = 0; i < n_rows; i++) {
-    for (auto j = 0; j < n_cols; j++) {
-      printf("%1.4f%c", h_matrix[j * n_rows + i],
-             j < n_cols - 1 ? h_separator : v_separator);
-    }
-  }
-}
-
-/**
- * @brief Prints the data stored in CPU memory
- * @param in: input matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- */
-template <typename m_t>
-void printHost(const m_t *in, int n_rows, int n_cols) {
-  for (auto i = 0; i < n_rows; i++) {
-    for (auto j = 0; j < n_cols; j++) {
-      printf("%1.4f ", in[j * n_rows + i]);
-    }
-    printf("\n");
-  }
-}
-
-/**
- * @brief Kernel for copying a slice of a big matrix to a small matrix with a
- * size matches that slice
- * @param src_d: input matrix
- * @param m: number of rows of input matrix
- * @param n: number of columns of input matrix
- * @param dst_d: output matrix
- * @param x1, y1: coordinate of the top-left point of the wanted area (0-based)
- * @param x2, y2: coordinate of the bottom-right point of the wanted area
- * (1-based)
- */
-template <typename m_t>
-__global__ void slice(m_t *src_d, int m, int n, m_t *dst_d, int x1, int y1,
-                      int x2, int y2) {
-  int idx = threadIdx.x + blockDim.x * blockIdx.x;
-  int dm = x2 - x1, dn = y2 - y1;
-  if (idx < dm * dn) {
-    int i = idx % dm, j = idx / dm;
-    int is = i + x1, js = j + y1;
-    dst_d[idx] = src_d[is + js * m];
-  }
-}
-
-/**
- * @brief Slice a matrix (in-place)
- * @param in: input matrix
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param out: output matrix
- * @param x1, y1: coordinate of the top-left point of the wanted area (0-based)
- * @param x2, y2: coordinate of the bottom-right point of the wanted area
- * (1-based)
- * example: Slice the 2nd and 3rd columns of a 4x3 matrix: slice_matrix(M_d, 4,
- * 3, 0, 1, 4, 3);
- * @param stream: cuda stream
- */
-template <typename m_t>
-void sliceMatrix(m_t *in, int n_rows, int n_cols, m_t *out, int x1, int y1,
-                 int x2, int y2, cudaStream_t stream) {
-  // Slicing
-  dim3 block(64);
-  dim3 grid(((x2 - x1) * (y2 - y1) + block.x - 1) / block.x);
-  slice<<<grid, block, 0, stream>>>(in, n_rows, n_cols, out, x1, y1, x2, y2);
-}
-
-/**
- * @brief Kernel for copying the upper triangular part of a matrix to another
- * @param src: input matrix with a size of mxn
- * @param dst: output matrix with a size of kxk
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param k: min(n_rows, n_cols)
- */
-template <typename m_t>
-__global__ void getUpperTriangular(m_t *src, m_t *dst, int n_rows, int n_cols,
-                                   int k) {
-  int idx = threadIdx.x + blockDim.x * blockIdx.x;
-  int m = n_rows, n = n_cols;
-  if (idx < m * n) {
-    int i = idx % m, j = idx / m;
-    if (i < k && j < k && j >= i) {
-      dst[i + j * k] = src[idx];
-    }
-  }
-}
-
-/**
- * @brief Copy the upper triangular part of a matrix to another
- * @param src: input matrix with a size of n_rows x n_cols
- * @param dst: output matrix with a size of kxk, k = min(n_rows, n_cols)
- * @param n_rows: number of rows of input matrix
- * @param n_cols: number of columns of input matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void copyUpperTriangular(m_t *src, m_t *dst, int n_rows, int n_cols,
-                         cudaStream_t stream) {
-  int m = n_rows, n = n_cols;
-  int k = min(m, n);
-  dim3 block(64);
-  dim3 grid((m * n + block.x - 1) / block.x);
-  getUpperTriangular<<<grid, block, 0, stream>>>(src, dst, m, n, k);
-}
-
-/**
- * @brief Copy a vector to the diagonal of a matrix
- * @param vec: vector of length k = min(n_rows, n_cols)
- * @param matrix: matrix of size n_rows x n_cols
- * @param m: number of rows of the matrix
- * @param n: number of columns of the matrix
- * @param k: dimensionality
- */
-template <typename m_t>
-__global__ void copyVectorToMatrixDiagonal(m_t *vec, m_t *matrix, int m, int n,
-                                           int k) {
-  int idx = threadIdx.x + blockDim.x * blockIdx.x;
-
-  if (idx < k) {
-    matrix[idx + idx * m] = vec[idx];
-  }
-}
-
-/**
- * @brief Initialize a diagonal matrix with a vector
- * @param vec: vector of length k = min(n_rows, n_cols)
- * @param matrix: matrix of size n_rows x n_cols
- * @param n_rows: number of rows of the matrix
- * @param n_cols: number of columns of the matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void initializeDiagonalMatrix(m_t *vec, m_t *matrix, int n_rows, int n_cols,
-                              cudaStream_t stream) {
-  int k = min(n_rows, n_cols);
-  dim3 block(64);
-  dim3 grid((k + block.x - 1) / block.x);
-  copyVectorToMatrixDiagonal<<<grid, block, 0, stream>>>(vec, matrix, n_rows,
-                                                         n_cols, k);
-}
-
-/**
- * @brief Calculate the inverse of the diagonal of a square matrix
- * element-wise and in place
- * @param in: square input matrix with size len x len
- * @param len: size of one side of the matrix
- */
-template <typename m_t>
-__global__ void matrixDiagonalInverse(m_t *in, int len) {
-  int idx = threadIdx.x + blockDim.x * blockIdx.x;
-  if (idx < len) {
-    in[idx + idx * len] = 1.0 / in[idx + idx * len];
-  }
-}
-
-/**
- * @brief Get a square matrix with elements on diagonal reversed (in-place)
- * @param in: square input matrix with size len x len
- * @param len: size of one side of the matrix
- * @param stream: cuda stream
- */
-template <typename m_t>
-void getDiagonalInverseMatrix(m_t *in, int len, cudaStream_t stream) {
-  dim3 block(64);
-  dim3 grid((len + block.x - 1) / block.x);
-  matrixDiagonalInverse<m_t><<<grid, block, 0, stream>>>(in, len);
-}
-
-/**
- * @brief Get the L2/F-norm of a matrix/vector
- * @param in: input matrix/vector with totally size elements
- * @param size: size of the matrix/vector
- * @param cublasH cublas handle
- * @param stream: cuda stream
- */
-template <typename m_t>
-m_t getL2Norm(const raft::handle_t &handle, m_t *in, int size,
-              cudaStream_t stream) {
-  cublasHandle_t cublasH = handle.get_cublas_handle();
-  m_t normval = 0;
-  CUBLAS_CHECK(
-    raft::linalg::cublasnrm2(cublasH, size, in, 1, &normval, stream));
-  return normval;
-}
-
-};  // end namespace matrix
-};  // end namespace raft
diff --git a/cpp/src_prims/matrix/reverse.cuh b/cpp/src_prims/matrix/reverse.cuh
index 2b510e448f..53ad9f24d1 100644
--- a/cpp/src_prims/matrix/reverse.cuh
+++ b/cpp/src_prims/matrix/reverse.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <cuda_utils.cuh>
-#include <vectorized.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/vectorized.cuh>
 
 namespace MLCommon {
 namespace Matrix {
diff --git a/cpp/src_prims/metrics/adjustedRandIndex.cuh b/cpp/src_prims/metrics/adjustedRandIndex.cuh
index a2ccb2b50c..febafa2396 100644
--- a/cpp/src_prims/metrics/adjustedRandIndex.cuh
+++ b/cpp/src_prims/metrics/adjustedRandIndex.cuh
@@ -22,14 +22,14 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/reduce.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/linalg/reduce.cuh>
 #include <stats/histogram.cuh>
 #include "contingencyMatrix.cuh"
 
diff --git a/cpp/src_prims/metrics/batched/information_criterion.cuh b/cpp/src_prims/metrics/batched/information_criterion.cuh
index fe918dd9a6..25500849e9 100644
--- a/cpp/src_prims/metrics/batched/information_criterion.cuh
+++ b/cpp/src_prims/metrics/batched/information_criterion.cuh
@@ -28,7 +28,7 @@
 #include <cuda_runtime.h>
 #include <cmath>
 
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/metrics/contingencyMatrix.cuh b/cpp/src_prims/metrics/contingencyMatrix.cuh
index f566c81f09..0203e1f639 100644
--- a/cpp/src_prims/metrics/contingencyMatrix.cuh
+++ b/cpp/src_prims/metrics/contingencyMatrix.cuh
@@ -16,12 +16,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <thrust/device_ptr.h>
 #include <thrust/reduce.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/metrics/dispersion.cuh b/cpp/src_prims/metrics/dispersion.cuh
index 2be0fae3b6..08fdc654ac 100644
--- a/cpp/src_prims/metrics/dispersion.cuh
+++ b/cpp/src_prims/metrics/dispersion.cuh
@@ -16,13 +16,13 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/eltwise.cuh>
 #include <memory>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/eltwise.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/metrics/entropy.cuh b/cpp/src_prims/metrics/entropy.cuh
index bf1d486aec..f0520200b3 100644
--- a/cpp/src_prims/metrics/entropy.cuh
+++ b/cpp/src_prims/metrics/entropy.cuh
@@ -18,14 +18,14 @@
 * @brief Calculates the entropy for a labeling in nats.(ie, uses natural logarithm for the calculations)
 */
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/divide.cuh>
-#include <linalg/map_then_reduce.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/divide.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/metrics/klDivergence.cuh b/cpp/src_prims/metrics/klDivergence.cuh
index 2a53243196..44bae7173e 100644
--- a/cpp/src_prims/metrics/klDivergence.cuh
+++ b/cpp/src_prims/metrics/klDivergence.cuh
@@ -21,12 +21,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/map_then_reduce.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/metrics/mutualInfoScore.cuh b/cpp/src_prims/metrics/mutualInfoScore.cuh
index d29c812f72..243451aef8 100644
--- a/cpp/src_prims/metrics/mutualInfoScore.cuh
+++ b/cpp/src_prims/metrics/mutualInfoScore.cuh
@@ -24,13 +24,13 @@
 *   on the same dataset when the real ground truth is not known.
 */
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/reduce.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/reduce.cuh>
 #include "contingencyMatrix.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/metrics/pairwiseDistance.cuh b/cpp/src_prims/metrics/pairwiseDistance.cuh
index abcd2d2ea2..8f4b98c2fd 100644
--- a/cpp/src_prims/metrics/pairwiseDistance.cuh
+++ b/cpp/src_prims/metrics/pairwiseDistance.cuh
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <distance/distance.cuh>
-#include <linalg/binary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/metrics/randIndex.cuh b/cpp/src_prims/metrics/randIndex.cuh
index e4f3a6a7cf..f4480b3abd 100644
--- a/cpp/src_prims/metrics/randIndex.cuh
+++ b/cpp/src_prims/metrics/randIndex.cuh
@@ -42,12 +42,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/metrics/scores.cuh b/cpp/src_prims/metrics/scores.cuh
index 31d9504a1f..62a3682741 100644
--- a/cpp/src_prims/metrics/scores.cuh
+++ b/cpp/src_prims/metrics/scores.cuh
@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/eltwise.cuh>
+#include <raft/cudart_utils.h>
 #include <linalg/power.cuh>
-#include <linalg/subtract.cuh>
-#include <stats/mean.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/stats/mean.cuh>
 
 #include <memory>
 
diff --git a/cpp/src_prims/metrics/silhouetteScore.cuh b/cpp/src_prims/metrics/silhouetteScore.cuh
index e080c3abae..b261cd18a1 100644
--- a/cpp/src_prims/metrics/silhouetteScore.cuh
+++ b/cpp/src_prims/metrics/silhouetteScore.cuh
@@ -14,22 +14,22 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <distance/distance.cuh>
 #include <iostream>
-#include <linalg/binary_op.cuh>
-#include <linalg/eltwise.cuh>
-#include <linalg/map_then_reduce.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/reduce.cuh>
 #include <linalg/reduce_cols_by_key.cuh>
 #include <numeric>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/eltwise.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/reduce.cuh>
 
 namespace MLCommon {
 namespace Metrics {
diff --git a/cpp/src_prims/random/make_arima.cuh b/cpp/src_prims/random/make_arima.cuh
index bcfaf634ad..5cf5bf5e29 100644
--- a/cpp/src_prims/random/make_arima.cuh
+++ b/cpp/src_prims/random/make_arima.cuh
@@ -24,8 +24,8 @@
 
 #include <cuml/tsa/arima_common.h>
 #include <cuml/common/cuml_allocator.hpp>
+#include <raft/random/rng.cuh>
 #include <timeSeries/arima_helpers.cuh>
-#include "rng.cuh"
 
 namespace MLCommon {
 namespace Random {
diff --git a/cpp/src_prims/random/make_blobs.cuh b/cpp/src_prims/random/make_blobs.cuh
index 4e962648ce..ff9cb5c79d 100644
--- a/cpp/src_prims/random/make_blobs.cuh
+++ b/cpp/src_prims/random/make_blobs.cuh
@@ -16,14 +16,14 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/random/rng.cuh>
 #include <vector>
 #include "permute.cuh"
-#include "rng.cuh"
 
 namespace MLCommon {
 namespace Random {
diff --git a/cpp/src_prims/random/make_regression.cuh b/cpp/src_prims/random/make_regression.cuh
index ebe47dc8e0..fbcc05d18a 100644
--- a/cpp/src_prims/random/make_regression.cuh
+++ b/cpp/src_prims/random/make_regression.cuh
@@ -23,17 +23,18 @@
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 
-#include <common/cudart_utils.h>
 #include <linalg/init.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
-#include <linalg/add.cuh>
-#include <linalg/qr.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/linalg/transpose.h>
+#include <common/device_buffer.hpp>
 #include <raft/handle.hpp>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/qr.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <raft/mr/device/buffer.hpp>
+#include <raft/random/rng.cuh>
 #include "permute.cuh"
-#include "rng.cuh"
 
 namespace MLCommon {
 namespace Random {
diff --git a/cpp/src_prims/random/mvg.cuh b/cpp/src_prims/random/mvg.cuh
index 274289e932..e5e3562140 100644
--- a/cpp/src_prims/random/mvg.cuh
+++ b/cpp/src_prims/random/mvg.cuh
@@ -15,14 +15,14 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <stdio.h>
 #include <cmath>
-#include <cuda_utils.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "curand_wrappers.h"
 
 // mvg.cuh takes in matrices that are colomn major (as in fortan)
diff --git a/cpp/src_prims/random/permute.cuh b/cpp/src_prims/random/permute.cuh
index aabaf33dec..f765668e61 100644
--- a/cpp/src_prims/random/permute.cuh
+++ b/cpp/src_prims/random/permute.cuh
@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <cooperative_groups.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <memory>
-#include <vectorized.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/vectorized.cuh>
 
 namespace MLCommon {
 namespace Random {
diff --git a/cpp/src_prims/random/rng.cuh b/cpp/src_prims/random/rng.cuh
deleted file mode 100644
index bc5f809692..0000000000
--- a/cpp/src_prims/random/rng.cuh
+++ /dev/null
@@ -1,676 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <stdint.h>
-#include <common/cub_wrappers.cuh>
-#include <common/scatter.cuh>
-#include <cstdio>
-#include <cstdlib>
-#include <cuda_utils.cuh>
-#include <raft/handle.hpp>
-#include <raft/mr/device/allocator.hpp>
-#include <raft/mr/device/buffer.hpp>
-#include <random>
-#include <type_traits>
-#include "rng_impl.cuh"
-
-namespace raft {
-namespace random {
-
-/** all different generator types used */
-enum GeneratorType {
-  /** curand-based philox generator */
-  GenPhilox = 0,
-  /** LFSR taps generator */
-  GenTaps,
-  /** kiss99 generator (currently the fastest) */
-  GenKiss99
-};
-
-template <typename OutType, typename MathType, typename GenType,
-          typename LenType, typename Lambda>
-__global__ void randKernel(uint64_t seed, uint64_t offset, OutType *ptr,
-                           LenType len, Lambda randOp) {
-  LenType tid = (blockIdx.x * blockDim.x) + threadIdx.x;
-  detail::Generator<GenType> gen(seed, (uint64_t)tid, offset);
-  const LenType stride = gridDim.x * blockDim.x;
-  for (LenType idx = tid; idx < len; idx += stride) {
-    MathType val;
-    gen.next(val);
-    ptr[idx] = randOp(val, idx);
-  }
-}
-
-// used for Box-Muller type transformations
-template <typename OutType, typename MathType, typename GenType,
-          typename LenType, typename Lambda2>
-__global__ void rand2Kernel(uint64_t seed, uint64_t offset, OutType *ptr,
-                            LenType len, Lambda2 rand2Op) {
-  LenType tid = (blockIdx.x * blockDim.x) + threadIdx.x;
-  detail::Generator<GenType> gen(seed, (uint64_t)tid, offset);
-  const LenType stride = gridDim.x * blockDim.x;
-  for (LenType idx = tid; idx < len; idx += stride) {
-    MathType val1, val2;
-    gen.next(val1);
-    gen.next(val2);
-    rand2Op(val1, val2, idx, idx + stride);
-    if (idx < len) ptr[idx] = (OutType)val1;
-    idx += stride;
-    if (idx < len) ptr[idx] = (OutType)val2;
-  }
-}
-
-template <typename Type>
-__global__ void constFillKernel(Type *ptr, int len, Type val) {
-  unsigned tid = (blockIdx.x * blockDim.x) + threadIdx.x;
-  const unsigned stride = gridDim.x * blockDim.x;
-  for (unsigned idx = tid; idx < len; idx += stride) {
-    ptr[idx] = val;
-  }
-}
-
-/**
- * @brief Helper method to compute Box Muller transform
- *
- * @tparam Type data type
- *
- * @param[inout] val1   first value
- * @param[inout] val2   second value
- * @param[in]    sigma1 standard deviation of output gaussian for first value
- * @param[in]    mu1    mean of output gaussian for first value
- * @param[in]    sigma2 standard deviation of output gaussian for second value
- * @param[in]    mu2    mean of output gaussian for second value
- * @{
- */
-template <typename Type>
-DI void box_muller_transform(Type &val1, Type &val2, Type sigma1, Type mu1,
-                             Type sigma2, Type mu2) {
-  constexpr Type twoPi = Type(2.0) * Type(3.141592654);
-  constexpr Type minus2 = -Type(2.0);
-  Type R = raft::mySqrt(minus2 * raft::myLog(val1));
-  Type theta = twoPi * val2;
-  Type s, c;
-  raft::mySinCos(theta, s, c);
-  val1 = R * c * sigma1 + mu1;
-  val2 = R * s * sigma2 + mu2;
-}
-template <typename Type>
-DI void box_muller_transform(Type &val1, Type &val2, Type sigma1, Type mu1) {
-  box_muller_transform<Type>(val1, val2, sigma1, mu1, sigma1, mu1);
-}
-/** @} */
-
-/** The main random number generator class, fully on GPUs */
-class Rng {
- public:
-  /**
-   * @brief ctor
-   * @param _s 64b seed used to initialize the RNG
-   * @param _t backend device RNG generator type
-   * @note Refer to the `Rng::seed` method for details about seeding the engine
-   */
-  Rng(uint64_t _s, GeneratorType _t = GenPhilox)
-    : type(_t),
-      offset(0),
-      // simple heuristic to make sure all SMs will be occupied properly
-      // and also not too many initialization calls will be made by each thread
-      nBlocks(4 * getMultiProcessorCount()),
-      gen() {
-    seed(_s);
-  }
-
-  /**
-   * @brief Seed (and thus re-initialize) the underlying RNG engine
-   * @param _s 64b seed used to initialize the RNG
-   * @note If you need non-reproducibility, pass a seed that's, for example, a
-   *       function of timestamp. Another example is to use the c++11's
-   *       `std::random_device` for setting seed.
-   */
-  void seed(uint64_t _s) {
-    gen.seed(_s);
-    offset = 0;
-  }
-
-  /**
-   * @brief Generates the 'a' and 'b' parameters for a modulo affine
-   *        transformation equation: `(ax + b) % n`
-   *
-   * @tparam IdxT integer type
-   *
-   * @param[in]  n the modulo range
-   * @param[out] a slope parameter
-   * @param[out] b intercept parameter
-   */
-  template <typename IdxT>
-  void affine_transform_params(IdxT n, IdxT &a, IdxT &b) {
-    // always keep 'a' to be coprime to 'n'
-    a = gen() % n;
-    while (gcd(a, n) != 1) {
-      ++a;
-      if (a >= n) a = 0;
-    }
-    // the bias term 'b' can be any number in the range of [0, n)
-    b = gen() % n;
-  }
-
-  /**
-   * @brief Generate uniformly distributed numbers in the given range
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output array
-   * @param len the number of elements in the output
-   * @param start start of the range
-   * @param end end of the range
-   * @param stream stream where to launch the kernel
-   * @{
-   */
-  template <typename Type, typename LenType = int>
-  void uniform(Type *ptr, LenType len, Type start, Type end,
-               cudaStream_t stream) {
-    static_assert(std::is_floating_point<Type>::value,
-                  "Type for 'uniform' can only be floating point!");
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        return (val * (end - start)) + start;
-      },
-      stream);
-  }
-  template <typename IntType, typename LenType = int>
-  void uniformInt(IntType *ptr, LenType len, IntType start, IntType end,
-                  cudaStream_t stream) {
-    static_assert(std::is_integral<IntType>::value,
-                  "Type for 'uniformInt' can only be integer!");
-    custom_distribution(
-      ptr, len,
-      [=] __device__(IntType val, LenType idx) {
-        return (val % (end - start)) + start;
-      },
-      stream);
-  }
-  /** @} */
-
-  /**
-   * @brief Generate normal distributed numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output array
-   * @param len the number of elements in the output
-   * @param mu mean of the distribution
-   * @param sigma std-dev of the distribution
-   * @param stream stream where to launch the kernel
-   * @{
-   */
-  template <typename Type, typename LenType = int>
-  void normal(Type *ptr, LenType len, Type mu, Type sigma,
-              cudaStream_t stream) {
-    static_assert(std::is_floating_point<Type>::value,
-                  "Type for 'normal' can only be floating point!");
-    rand2Impl(
-      offset, ptr, len,
-      [=] __device__(Type & val1, Type & val2, LenType idx1, LenType idx2) {
-        box_muller_transform<Type>(val1, val2, sigma, mu);
-      },
-      NumThreads, nBlocks, type, stream);
-  }
-  template <typename IntType, typename LenType = int>
-  void normalInt(IntType *ptr, LenType len, IntType mu, IntType sigma,
-                 cudaStream_t stream) {
-    static_assert(std::is_integral<IntType>::value,
-                  "Type for 'normalInt' can only be integer!");
-    rand2Impl<IntType, double>(
-      offset, ptr, len,
-      [=] __device__(double &val1, double &val2, LenType idx1, LenType idx2) {
-        box_muller_transform<double>(val1, val2, sigma, mu);
-      },
-      NumThreads, nBlocks, type, stream);
-  }
-  /** @} */
-
-  /**
-   * @brief Generate normal distributed table according to the given set of
-   * means and scalar standard deviations.
-   *
-   * Each row in this table conforms to a normally distributed n-dim vector
-   * whose mean is the input vector and standard deviation is the corresponding
-   * vector or scalar. Correlations among the dimensions itself is assumed to
-   * be absent.
-   *
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output table (dim = n_rows x n_cols)
-   * @param n_rows number of rows in the table
-   * @param n_cols number of columns in the table
-   * @param mu mean vector (dim = n_cols x 1).
-   * @param sigma_vec std-dev vector of each component (dim = n_cols x 1). Pass
-   * a nullptr to use the same scalar 'sigma' across all components
-   * @param sigma scalar sigma to be used if 'sigma_vec' is nullptr
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void normalTable(Type *ptr, LenType n_rows, LenType n_cols, const Type *mu,
-                   const Type *sigma_vec, Type sigma, cudaStream_t stream) {
-    rand2Impl(
-      offset, ptr, n_rows * n_cols,
-      [=] __device__(Type & val1, Type & val2, LenType idx1, LenType idx2) {
-        // yikes! use fast-int-div
-        auto col1 = idx1 % n_cols;
-        auto col2 = idx2 % n_cols;
-        auto mean1 = mu[col1];
-        auto mean2 = mu[col2];
-        auto sig1 = sigma_vec == nullptr ? sigma : sigma_vec[col1];
-        auto sig2 = sigma_vec == nullptr ? sigma : sigma_vec[col2];
-        box_muller_transform<Type>(val1, val2, sig1, mean1, sig2, mean2);
-      },
-      NumThreads, nBlocks, type, stream);
-  }
-
-  /**
-   * @brief Fill an array with the given value
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output array
-   * @param len the number of elements in the output
-   * @param val value to be filled
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void fill(Type *ptr, LenType len, Type val, cudaStream_t stream) {
-    constFillKernel<Type><<<nBlocks, NumThreads, 0, stream>>>(ptr, len, val);
-    CUDA_CHECK(cudaPeekAtLastError());
-  }
-
-  /**
-   * @brief Generate bernoulli distributed boolean array
-   *
-   * @tparam Type    data type in which to compute the probabilities
-   * @tparam OutType output data type
-   * @tparam LenType data type used to represent length of the arrays
-   *
-   * @param[out] ptr    the output array
-   * @param[in]  len    the number of elements in the output
-   * @param[in]  prob   coin-toss probability for heads
-   * @param[in]  stream stream where to launch the kernel
-   */
-  template <typename Type, typename OutType = bool, typename LenType = int>
-  void bernoulli(OutType *ptr, LenType len, Type prob, cudaStream_t stream) {
-    custom_distribution<OutType, Type>(
-      ptr, len, [=] __device__(Type val, LenType idx) { return val > prob; },
-      stream);
-  }
-
-  /**
-   * @brief Generate bernoulli distributed array and applies scale
-   * @tparam Type data type in which to compute the probabilities
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output array
-   * @param len the number of elements in the output
-   * @param prob coin-toss probability for heads
-   * @param scale scaling factor
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void scaled_bernoulli(Type *ptr, LenType len, Type prob, Type scale,
-                        cudaStream_t stream) {
-    static_assert(std::is_floating_point<Type>::value,
-                  "Type for 'scaled_bernoulli' can only be floating point!");
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        return val > prob ? -scale : scale;
-      },
-      stream);
-  }
-
-  /**
-   * @brief Generate gumbel distributed random numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr output array
-   * @param len number of elements in the output array
-   * @param mu mean value
-   * @param beta scale value
-   * @param stream stream where to launch the kernel
-   * @note https://en.wikipedia.org/wiki/Gumbel_distribution
-   */
-  template <typename Type, typename LenType = int>
-  void gumbel(Type *ptr, LenType len, Type mu, Type beta, cudaStream_t stream) {
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        return mu - beta * raft::myLog(-raft::myLog(val));
-      },
-      stream);
-  }
-
-  /**
-   * @brief Generate lognormal distributed numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr the output array
-   * @param len the number of elements in the output
-   * @param mu mean of the distribution
-   * @param sigma std-dev of the distribution
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void lognormal(Type *ptr, LenType len, Type mu, Type sigma,
-                 cudaStream_t stream) {
-    rand2Impl(
-      offset, ptr, len,
-      [=] __device__(Type & val1, Type & val2, LenType idx1, LenType idx2) {
-        box_muller_transform<Type>(val1, val2, sigma, mu);
-        val1 = raft::myExp(val1);
-        val2 = raft::myExp(val2);
-      },
-      NumThreads, nBlocks, type, stream);
-  }
-
-  /**
-   * @brief Generate logistic distributed random numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr output array
-   * @param len number of elements in the output array
-   * @param mu mean value
-   * @param scale scale value
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void logistic(Type *ptr, LenType len, Type mu, Type scale,
-                cudaStream_t stream) {
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        constexpr Type one = (Type)1.0;
-        return mu - scale * raft::myLog(one / val - one);
-      },
-      stream);
-  }
-
-  /**
-   * @brief Generate exponentially distributed random numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr output array
-   * @param len number of elements in the output array
-   * @param lambda the lambda
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void exponential(Type *ptr, LenType len, Type lambda, cudaStream_t stream) {
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        constexpr Type one = (Type)1.0;
-        return -raft::myLog(one - val) / lambda;
-      },
-      stream);
-  }
-
-  /**
-   * @brief Generate rayleigh distributed random numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr output array
-   * @param len number of elements in the output array
-   * @param sigma the sigma
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void rayleigh(Type *ptr, LenType len, Type sigma, cudaStream_t stream) {
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        constexpr Type one = (Type)1.0;
-        constexpr Type two = (Type)2.0;
-        return raft::mySqrt(-two * raft::myLog(one - val)) * sigma;
-      },
-      stream);
-  }
-
-  /**
-   * @brief Generate laplace distributed random numbers
-   * @tparam Type data type of output random number
-   * @tparam LenType data type used to represent length of the arrays
-   * @param ptr output array
-   * @param len number of elements in the output array
-   * @param mu the mean
-   * @param scale the scale
-   * @param stream stream where to launch the kernel
-   */
-  template <typename Type, typename LenType = int>
-  void laplace(Type *ptr, LenType len, Type mu, Type scale,
-               cudaStream_t stream) {
-    custom_distribution(
-      ptr, len,
-      [=] __device__(Type val, LenType idx) {
-        constexpr Type one = (Type)1.0;
-        constexpr Type two = (Type)2.0;
-        constexpr Type oneHalf = (Type)0.5;
-        Type out;
-        if (val <= oneHalf) {
-          out = mu + scale * raft::myLog(two * val);
-        } else {
-          out = mu - scale * raft::myLog(two * (one - val));
-        }
-        return out;
-      },
-      stream);
-  }
-
-  /**
-   * @brief Sample the input array without replacement, optionally based on the
-   * input weight vector for each element in the array
-   *
-   * Implementation here is based on the `one-pass sampling` algo described here:
-   * https://www.ethz.ch/content/dam/ethz/special-interest/baug/ivt/ivt-dam/vpl/reports/1101-1200/ab1141.pdf
-   *
-   * @note In the sampled array the elements which are picked will always appear
-   * in the increasing order of their weights as computed using the exponential
-   * distribution. So, if you're particular about the order (for eg. array
-   * permutations), then this might not be the right choice!
-   *
-   * @tparam DataT data type
-   * @tparam WeightsT weights type
-   * @tparam IdxT index type
-   * @param out output sampled array (of length 'sampledLen')
-   * @param outIdx indices of the sampled array (of length 'sampledLen'). Pass
-   * a nullptr if this is not required.
-   * @param in input array to be sampled (of length 'len')
-   * @param wts weights array (of length 'len'). Pass a nullptr if uniform
-   * sampling is desired
-   * @param sampledLen output sampled array length
-   * @param len input array length
-   * @param allocator device allocator for allocating any workspace required
-   * @param stream cuda stream
-   */
-  template <typename DataT, typename WeightsT, typename IdxT = int>
-  void sampleWithoutReplacement(const raft::handle_t &handle, DataT *out,
-                                IdxT *outIdx, const DataT *in,
-                                const WeightsT *wts, IdxT sampledLen, IdxT len,
-                                cudaStream_t stream) {
-    ASSERT(sampledLen <= len,
-           "sampleWithoutReplacement: 'sampledLen' cant be more than 'len'.");
-
-    std::shared_ptr<raft::mr::device::allocator> allocator =
-      handle.get_device_allocator();
-
-    raft::mr::device::buffer<WeightsT> expWts(allocator, stream, len);
-    raft::mr::device::buffer<WeightsT> sortedWts(allocator, stream, len);
-    raft::mr::device::buffer<IdxT> inIdx(allocator, stream, len);
-    raft::mr::device::buffer<IdxT> outIdxBuff(allocator, stream, len);
-    auto *inIdxPtr = inIdx.data();
-    // generate modified weights
-    custom_distribution(
-      expWts.data(), len,
-      [wts, inIdxPtr] __device__(WeightsT val, IdxT idx) {
-        inIdxPtr[idx] = idx;
-        constexpr WeightsT one = (WeightsT)1.0;
-        auto exp = -raft::myLog(one - val);
-        if (wts != nullptr) {
-          return exp / wts[idx];
-        }
-        return exp;
-      },
-      stream);
-    ///@todo: use a more efficient partitioning scheme instead of full sort
-    // sort the array and pick the top sampledLen items
-    IdxT *outIdxPtr = outIdxBuff.data();
-    raft::mr::device::buffer<char> workspace(allocator, stream);
-    sortPairs(workspace, expWts.data(), sortedWts.data(), inIdxPtr, outIdxPtr,
-              (int)len, stream);
-    if (outIdx != nullptr) {
-      CUDA_CHECK(cudaMemcpyAsync(outIdx, outIdxPtr, sizeof(IdxT) * sampledLen,
-                                 cudaMemcpyDeviceToDevice, stream));
-    }
-    scatter<DataT, IdxT>(out, in, outIdxPtr, sampledLen, stream);
-  }
-
-  /**
-   * @brief Core method to generate a pdf based on the cdf that is defined in
-   *        the input device lambda
-   *
-   * @tparam OutType  output type
-   * @tparam MathType type on which arithmetic is done
-   * @tparam LenTyp   index type
-   * @tparam Lambda   device lambda (or operator)
-   *
-   * @param[out] ptr    output buffer [on device] [len = len]
-   * @param[in]  len    number of elements to be generated
-   * @param[in]  randOp the device lambda or operator
-   * @param[in]  stream cuda stream
-   * @{
-   */
-  template <typename OutType, typename MathType = OutType,
-            typename LenType = int, typename Lambda>
-  void custom_distribution(OutType *ptr, LenType len, Lambda randOp,
-                           cudaStream_t stream) {
-    randImpl<OutType, MathType, LenType, Lambda>(
-      offset, ptr, len, randOp, NumThreads, nBlocks, type, stream);
-  }
-  template <typename OutType, typename MathType = OutType,
-            typename LenType = int, typename Lambda>
-  void custom_distribution2(OutType *ptr, LenType len, Lambda randOp,
-                            cudaStream_t stream) {
-    rand2Impl<OutType, MathType, LenType, Lambda>(
-      offset, ptr, len, randOp, NumThreads, nBlocks, type, stream);
-  }
-  /** @} */
-
- private:
-  /** generator type */
-  GeneratorType type;
-  /**
-   * offset is also used to initialize curand state.
-   * Limits period of Philox RNG from (4 * 2^128) to (Blocks * Threads * 2^64),
-   * but is still a large period.
-   */
-  uint64_t offset;
-  /** number of blocks to launch */
-  int nBlocks;
-  /** next seed generator for device-side RNG */
-  std::mt19937_64 gen;
-
-  static const int NumThreads = 256;
-
-  template <bool IsNormal, typename Type, typename LenType>
-  uint64_t _setupSeeds(uint64_t &seed, uint64_t &offset, LenType len,
-                       int nThreads, int nBlocks) {
-    LenType itemsPerThread = raft::ceildiv(len, LenType(nBlocks * nThreads));
-    if (IsNormal && itemsPerThread % 2 == 1) {
-      ++itemsPerThread;
-    }
-    // curand uses 2 32b uint's to generate one double
-    uint64_t factor = sizeof(Type) / sizeof(float);
-    if (factor == 0) ++factor;
-    // Check if there are enough random numbers left in sequence
-    // If not, then generate new seed and start from zero offset
-    uint64_t newOffset = offset + LenType(itemsPerThread) * factor;
-    if (newOffset < offset) {
-      offset = 0;
-      seed = gen();
-      newOffset = itemsPerThread * factor;
-    }
-    return newOffset;
-  }
-
-  template <typename OutType, typename MathType = OutType,
-            typename LenType = int, typename Lambda>
-  void randImpl(uint64_t &offset, OutType *ptr, LenType len, Lambda randOp,
-                int nThreads, int nBlocks, GeneratorType type,
-                cudaStream_t stream) {
-    if (len <= 0) return;
-    uint64_t seed = gen();
-    auto newOffset = _setupSeeds<false, MathType, LenType>(seed, offset, len,
-                                                           nThreads, nBlocks);
-    switch (type) {
-      case GenPhilox:
-        randKernel<OutType, MathType, detail::PhiloxGenerator, LenType, Lambda>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, randOp);
-        break;
-      case GenTaps:
-        randKernel<OutType, MathType, detail::TapsGenerator, LenType, Lambda>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, randOp);
-        break;
-      case GenKiss99:
-        randKernel<OutType, MathType, detail::Kiss99Generator, LenType, Lambda>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, randOp);
-        break;
-      default:
-        ASSERT(false, "randImpl: Incorrect generator type! %d", type);
-    };
-    CUDA_CHECK(cudaGetLastError());
-    offset = newOffset;
-  }
-
-  template <typename OutType, typename MathType = OutType,
-            typename LenType = int, typename Lambda2>
-  void rand2Impl(uint64_t &offset, OutType *ptr, LenType len, Lambda2 rand2Op,
-                 int nThreads, int nBlocks, GeneratorType type,
-                 cudaStream_t stream) {
-    if (len <= 0) return;
-    auto seed = gen();
-    auto newOffset = _setupSeeds<true, MathType, LenType>(seed, offset, len,
-                                                          nThreads, nBlocks);
-    switch (type) {
-      case GenPhilox:
-        rand2Kernel<OutType, MathType, detail::PhiloxGenerator, LenType,
-                    Lambda2>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, rand2Op);
-        break;
-      case GenTaps:
-        rand2Kernel<OutType, MathType, detail::TapsGenerator, LenType, Lambda2>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, rand2Op);
-        break;
-      case GenKiss99:
-        rand2Kernel<OutType, MathType, detail::Kiss99Generator, LenType,
-                    Lambda2>
-          <<<nBlocks, nThreads, 0, stream>>>(seed, offset, ptr, len, rand2Op);
-        break;
-      default:
-        ASSERT(false, "rand2Impl: Incorrect generator type! %d", type);
-    };
-    CUDA_CHECK(cudaGetLastError());
-    offset = newOffset;
-  }
-};
-
-};  // end namespace random
-};  // end namespace raft
diff --git a/cpp/src_prims/random/rng_impl.cuh b/cpp/src_prims/random/rng_impl.cuh
deleted file mode 100644
index 8ccf2b72e4..0000000000
--- a/cpp/src_prims/random/rng_impl.cuh
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <curand_kernel.h>
-#include <stdint.h>
-#include <cuda_utils.cuh>
-
-namespace raft {
-namespace random {
-namespace detail {
-
-/** Philox-based random number generator */
-// Courtesy: Jakub Szuppe
-struct PhiloxGenerator {
-  /**
-   * @brief ctor. Initializes the state for RNG
-   * @param seed random seed (can be same across all threads)
-   * @param subsequence as found in curand docs
-   * @param offset as found in curand docs
-   */
-  DI PhiloxGenerator(uint64_t seed, uint64_t subsequence, uint64_t offset) {
-    curand_init(seed, subsequence, offset, &state);
-  }
-
-  /**
-   * @defgroup NextRand Generate the next random number
-   * @{
-   */
-  DI void next(float& ret) { ret = curand_uniform(&(this->state)); }
-  DI void next(double& ret) { ret = curand_uniform_double(&(this->state)); }
-  DI void next(uint32_t& ret) { ret = curand(&(this->state)); }
-  DI void next(uint64_t& ret) {
-    uint32_t a, b;
-    next(a);
-    next(b);
-    ret = (uint64_t)a | ((uint64_t)b << 32);
-  }
-  DI void next(int32_t& ret) {
-    uint32_t val;
-    next(val);
-    ret = int32_t(val & 0x7fffffff);
-  }
-  DI void next(int64_t& ret) {
-    uint64_t val;
-    next(val);
-    ret = int64_t(val & 0x7fffffffffffffff);
-  }
-  /** @} */
-
- private:
-  /** the state for RNG */
-  curandStatePhilox4_32_10_t state;
-};
-
-/** LFSR taps-filter for generating random numbers. */
-// Courtesy: Vinay Deshpande
-struct TapsGenerator {
-  /**
-   * @brief ctor. Initializes the state for RNG
-   * @param seed the seed (can be same across all threads)
-   * @param subsequence unused
-   * @param offset unused
-   */
-  DI TapsGenerator(uint64_t seed, uint64_t subsequence, uint64_t offset) {
-    uint64_t delta = (blockIdx.x * blockDim.x) + threadIdx.x;
-    uint64_t stride = blockDim.x * gridDim.x;
-    delta += ((blockIdx.y * blockDim.y) + threadIdx.y) * stride;
-    stride *= blockDim.y * gridDim.y;
-    delta += ((blockIdx.z * blockDim.z) + threadIdx.z) * stride;
-    state = seed + delta + 1;
-  }
-
-  /**
-   * @defgroup NextRand Generate the next random number
-   * @{
-   */
-  template <typename Type>
-  DI void next(Type& ret) {
-    constexpr double ULL_LARGE = 1.8446744073709551614e19;
-    uint64_t val;
-    next(val);
-    ret = static_cast<Type>(val);
-    ret /= static_cast<Type>(ULL_LARGE);
-  }
-  DI void next(uint64_t& ret) {
-    constexpr uint64_t TAPS = 0x8000100040002000ULL;
-    constexpr int ROUNDS = 128;
-    for (int i = 0; i < ROUNDS; i++)
-      state = (state >> 1) ^ (-(state & 1ULL) & TAPS);
-    ret = state;
-  }
-  DI void next(uint32_t& ret) {
-    uint64_t val;
-    next(val);
-    ret = (uint32_t)val;
-  }
-  DI void next(int32_t& ret) {
-    uint32_t val;
-    next(val);
-    ret = int32_t(val & 0x7fffffff);
-  }
-  DI void next(int64_t& ret) {
-    uint64_t val;
-    next(val);
-    ret = int64_t(val & 0x7fffffffffffffff);
-  }
-  /** @} */
-
- private:
-  /** the state for RNG */
-  uint64_t state;
-};
-
-/** Kiss99-based random number generator */
-
-struct Kiss99Generator {
-  /**
-   * @brief ctor. Initializes the state for RNG
-   * @param seed the seed (can be same across all threads)
-   * @param subsequence unused
-   * @param offset unused
-   */
-  DI Kiss99Generator(uint64_t seed, uint64_t subsequence, uint64_t offset) {
-    initKiss99(seed);
-  }
-
-  /**
-   * @defgroup NextRand Generate the next random number
-   * @{
-   */
-  template <typename Type>
-  DI void next(Type& ret) {
-    constexpr double U_LARGE = 4.294967295e9;
-    uint32_t val;
-    next(val);
-    ret = static_cast<Type>(val);
-    ret /= static_cast<Type>(U_LARGE);
-  }
-  DI void next(uint32_t& ret) {
-    uint32_t MWC;
-    z = 36969 * (z & 65535) + (z >> 16);
-    w = 18000 * (w & 65535) + (w >> 16);
-    MWC = ((z << 16) + w);
-    jsr ^= (jsr << 17);
-    jsr ^= (jsr >> 13);
-    jsr ^= (jsr << 5);
-    jcong = 69069 * jcong + 1234567;
-    MWC = ((MWC ^ jcong) + jsr);
-    ret = MWC;
-  }
-  DI void next(uint64_t& ret) {
-    uint32_t a, b;
-    next(a);
-    next(b);
-    ret = (uint64_t)a | ((uint64_t)b << 32);
-  }
-  DI void next(int32_t& ret) {
-    uint32_t val;
-    next(val);
-    ret = int32_t(val & 0x7fffffff);
-  }
-  DI void next(int64_t& ret) {
-    uint64_t val;
-    next(val);
-    ret = int64_t(val & 0x7fffffffffffffff);
-  }
-  /** @} */
-
- private:
-  /** one of the kiss99 states */
-  uint32_t z;
-  /** one of the kiss99 states */
-  uint32_t w;
-  /** one of the kiss99 states */
-  uint32_t jsr;
-  /** one of the kiss99 states */
-  uint32_t jcong;
-
-  // This function multiplies 128-bit hash by 128-bit FNV prime and returns lower
-  // 128 bits. It uses 32-bit wide multiply only.
-  DI void mulByFnv1a128Prime(uint32_t* h) {
-    typedef union {
-      uint32_t u32[2];
-      uint64_t u64[1];
-    } words64;
-
-    // 128-bit FNV prime = p3 * 2^96 + p2 * 2^64 + p1 * 2^32 + p0
-    // Here p0 = 315, p2 = 16777216, p1 = p3 = 0
-    const uint32_t p0 = uint32_t(315), p2 = uint32_t(16777216);
-    // Partial products
-    words64 h0p0, h1p0, h2p0, h0p2, h3p0, h1p2;
-
-    h0p0.u64[0] = uint64_t(h[0]) * p0;
-    h1p0.u64[0] = uint64_t(h[1]) * p0;
-    h2p0.u64[0] = uint64_t(h[2]) * p0;
-    h0p2.u64[0] = uint64_t(h[0]) * p2;
-    h3p0.u64[0] = uint64_t(h[3]) * p0;
-    h1p2.u64[0] = uint64_t(h[1]) * p2;
-
-    // h_n[0] = LO(h[0]*p[0]);
-    // h_n[1] = HI(h[0]*p[0]) + LO(h[1]*p[0]);
-    // h_n[2] = HI(h[1]*p[0]) + LO(h[2]*p[0]) + LO(h[0]*p[2]);
-    // h_n[3] = HI(h[2]*p[0]) + HI(h[0]*p[2]) + LO(h[3]*p[0]) + LO(h[1]*p[2]);
-    uint32_t carry = 0;
-    h[0] = h0p0.u32[0];
-
-    h[1] = h0p0.u32[1] + h1p0.u32[0];
-    carry = h[1] < h0p0.u32[1] ? 1 : 0;
-
-    h[2] = h1p0.u32[1] + carry;
-    carry = h[2] < h1p0.u32[1] ? 1 : 0;
-    h[2] += h2p0.u32[0];
-    carry = h[2] < h2p0.u32[0] ? carry + 1 : carry;
-    h[2] += h0p2.u32[0];
-    carry = h[2] < h0p2.u32[0] ? carry + 1 : carry;
-
-    h[3] = h2p0.u32[1] + h0p2.u32[1] + h3p0.u32[0] + h1p2.u32[0] + carry;
-    return;
-  }
-
-  DI void fnv1a128(uint32_t* hash, uint32_t txt) {
-    hash[0] ^= (txt >> 0) & 0xFF;
-    mulByFnv1a128Prime(hash);
-    hash[0] ^= (txt >> 8) & 0xFF;
-    mulByFnv1a128Prime(hash);
-    hash[0] ^= (txt >> 16) & 0xFF;
-    mulByFnv1a128Prime(hash);
-    hash[0] ^= (txt >> 24) & 0xFF;
-    mulByFnv1a128Prime(hash);
-  }
-
-  DI void initKiss99(uint64_t seed) {
-    // Initialize hash to 128-bit FNV1a basis
-    uint32_t hash[4] = {1653982605UL, 1656234357UL, 129696066UL, 1818371886UL};
-
-    // Digest threadIdx, blockIdx and seed
-    fnv1a128(hash, threadIdx.x);
-    fnv1a128(hash, threadIdx.y);
-    fnv1a128(hash, threadIdx.z);
-    fnv1a128(hash, blockIdx.x);
-    fnv1a128(hash, blockIdx.y);
-    fnv1a128(hash, blockIdx.z);
-    fnv1a128(hash, uint32_t(seed));
-    fnv1a128(hash, uint32_t(seed >> 32));
-
-    // Initialize KISS99 state with hash
-    z = hash[0];
-    w = hash[1];
-    jsr = hash[2];
-    jcong = hash[3];
-  }
-};
-
-/**
- * @brief generator-agnostic way of generating random numbers
- * @tparam GenType the generator object that expose 'next' method
- */
-template <typename GenType>
-struct Generator {
-  DI Generator(uint64_t seed, uint64_t subsequence, uint64_t offset)
-    : gen(seed, subsequence, offset) {}
-
-  template <typename Type>
-  DI void next(Type& ret) {
-    gen.next(ret);
-  }
-
- private:
-  /** the actual generator */
-  GenType gen;
-};
-
-};  // end namespace detail
-};  // end namespace random
-};  // end namespace raft
diff --git a/cpp/src_prims/selection/columnWiseSort.cuh b/cpp/src_prims/selection/columnWiseSort.cuh
index fe44b18c76..b6f62820aa 100644
--- a/cpp/src_prims/selection/columnWiseSort.cuh
+++ b/cpp/src_prims/selection/columnWiseSort.cuh
@@ -18,7 +18,7 @@
 
 #include <cuda_runtime.h>
 #include <cstddef>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <cub/cub.cuh>
 #include <limits>
diff --git a/cpp/src_prims/selection/knn.cuh b/cpp/src_prims/selection/knn.cuh
index 7ca783cdab..23afcc1f49 100644
--- a/cpp/src_prims/selection/knn.cuh
+++ b/cpp/src_prims/selection/knn.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 #include <distance/distance.cuh>
 #include <label/classlabels.cuh>
diff --git a/cpp/src_prims/selection/kselection.cuh b/cpp/src_prims/selection/kselection.cuh
index 52d0ae52c7..21c0244eb9 100644
--- a/cpp/src_prims/selection/kselection.cuh
+++ b/cpp/src_prims/selection/kselection.cuh
@@ -17,8 +17,8 @@
 #pragma once
 
 #include <stdlib.h>
-#include <cuda_utils.cuh>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Selection {
diff --git a/cpp/src_prims/selection/processing.cuh b/cpp/src_prims/selection/processing.cuh
index b1d722522d..911bea4da1 100644
--- a/cpp/src_prims/selection/processing.cuh
+++ b/cpp/src_prims/selection/processing.cuh
@@ -17,12 +17,12 @@
 
 #include <cuml/neighbors/knn.hpp>
 
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/norm.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/linalg/unary_op.cuh>
 
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
+#include <raft/stats/mean.cuh>
+#include <raft/stats/mean_center.cuh>
 
 #include <common/device_buffer.hpp>
 
diff --git a/cpp/src_prims/sparse/batched/csr.cuh b/cpp/src_prims/sparse/batched/csr.cuh
index 9f697b4503..c7b95e7bc3 100644
--- a/cpp/src_prims/sparse/batched/csr.cuh
+++ b/cpp/src_prims/sparse/batched/csr.cuh
@@ -37,11 +37,11 @@
 #include <cuml/common/utils.hpp>
 #include <cuml/cuml.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <common/device_buffer.hpp>
 #include <linalg/batched/matrix.cuh>
-#include <matrix/matrix.cuh>
+#include <raft/matrix/matrix.cuh>
 
 namespace MLCommon {
 namespace Sparse {
diff --git a/cpp/src_prims/sparse/coo.cuh b/cpp/src_prims/sparse/coo.cuh
index 4d2ddf8f6c..abe3664e9a 100644
--- a/cpp/src_prims/sparse/coo.cuh
+++ b/cpp/src_prims/sparse/coo.cuh
@@ -27,9 +27,9 @@
 #include <thrust/device_vector.h>
 #include <thrust/scan.h>
 
-#include <common/cudart_utils.h>
 #include <cuda_runtime.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 #include <iostream>
 #define restrict __restrict__
diff --git a/cpp/src_prims/sparse/csr.cuh b/cpp/src_prims/sparse/csr.cuh
index 8a3ecaf4c9..06d9806646 100644
--- a/cpp/src_prims/sparse/csr.cuh
+++ b/cpp/src_prims/sparse/csr.cuh
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 
 #include <label/classlabels.cuh>
 
diff --git a/cpp/src_prims/sparse/spectral.cuh b/cpp/src_prims/sparse/spectral.cuh
index 3065d86a3a..fe94d52ef0 100644
--- a/cpp/src_prims/sparse/spectral.cuh
+++ b/cpp/src_prims/sparse/spectral.cuh
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/sparse/cusparse_wrappers.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
+#include <raft/cuda_utils.cuh>
 #include <selection/knn.cuh>
 #include "coo.cuh"
 
diff --git a/cpp/src_prims/stats/cov.cuh b/cpp/src_prims/stats/cov.cuh
index ea3e7c4dbe..02e90de650 100644
--- a/cpp/src_prims/stats/cov.cuh
+++ b/cpp/src_prims/stats/cov.cuh
@@ -17,8 +17,8 @@
 #pragma once
 
 #include <raft/linalg/cublas_wrappers.h>
-#include <linalg/gemm.cuh>
-#include "mean_center.cuh"
+#include <raft/linalg/gemm.cuh>
+#include <raft/stats/mean_center.cuh>
 
 namespace MLCommon {
 namespace Stats {
diff --git a/cpp/src_prims/stats/histogram.cuh b/cpp/src_prims/stats/histogram.cuh
index d62451db12..453a30428c 100644
--- a/cpp/src_prims/stats/histogram.cuh
+++ b/cpp/src_prims/stats/histogram.cuh
@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <stdint.h>
 #include <common/seive.cuh>
-#include <cuda_utils.cuh>
-#include <vectorized.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/vectorized.cuh>
 
 // This file is a shameless amalgamation of independent works done by
 // Lars Nyland and Andy Adinets
diff --git a/cpp/src_prims/stats/mean.cuh b/cpp/src_prims/stats/mean.cuh
deleted file mode 100644
index bb565ed971..0000000000
--- a/cpp/src_prims/stats/mean.cuh
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <linalg/eltwise.cuh>
-#include <raft/handle.hpp>
-
-namespace raft {
-namespace stats {
-
-///@todo: ColsPerBlk has been tested only for 32!
-template <typename Type, typename IdxType, int TPB, int ColsPerBlk = 32>
-__global__ void meanKernelRowMajor(Type *mu, const Type *data, IdxType D,
-                                   IdxType N) {
-  const int RowsPerBlkPerIter = TPB / ColsPerBlk;
-  IdxType thisColId = threadIdx.x % ColsPerBlk;
-  IdxType thisRowId = threadIdx.x / ColsPerBlk;
-  IdxType colId = thisColId + ((IdxType)blockIdx.y * ColsPerBlk);
-  IdxType rowId = thisRowId + ((IdxType)blockIdx.x * RowsPerBlkPerIter);
-  Type thread_data = Type(0);
-  const IdxType stride = RowsPerBlkPerIter * gridDim.x;
-  for (IdxType i = rowId; i < N; i += stride)
-    thread_data += (colId < D) ? data[i * D + colId] : Type(0);
-  __shared__ Type smu[ColsPerBlk];
-  if (threadIdx.x < ColsPerBlk) smu[threadIdx.x] = Type(0);
-  __syncthreads();
-  raft::myAtomicAdd(smu + thisColId, thread_data);
-  __syncthreads();
-  if (threadIdx.x < ColsPerBlk) raft::myAtomicAdd(mu + colId, smu[thisColId]);
-}
-
-template <typename Type, typename IdxType, int TPB>
-__global__ void meanKernelColMajor(Type *mu, const Type *data, IdxType D,
-                                   IdxType N) {
-  typedef cub::BlockReduce<Type, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  Type thread_data = Type(0);
-  IdxType colStart = N * blockIdx.x;
-  for (IdxType i = threadIdx.x; i < N; i += TPB) {
-    IdxType idx = colStart + i;
-    thread_data += data[idx];
-  }
-  Type acc = BlockReduce(temp_storage).Sum(thread_data);
-  if (threadIdx.x == 0) {
-    mu[blockIdx.x] = acc / N;
-  }
-}
-
-/**
- * @brief Compute mean of the input matrix
- *
- * Mean operation is assumed to be performed on a given column.
- *
- * @tparam Type: the data type
- * @tparam IdxType Integer type used to for addressing
- * @param mu: the output mean vector
- * @param data: the input matrix
- * @param D: number of columns of data
- * @param N: number of rows of data
- * @param sample: whether to evaluate sample mean or not. In other words,
- * whether
- *  to normalize the output using N-1 or N, for true or false, respectively
- * @param rowMajor: whether the input data is row or col major
- * @param stream: cuda stream
- */
-template <typename Type, typename IdxType = int>
-void mean(Type *mu, const Type *data, IdxType D, IdxType N, bool sample,
-          bool rowMajor, cudaStream_t stream) {
-  static const int TPB = 256;
-  if (rowMajor) {
-    static const int RowsPerThread = 4;
-    static const int ColsPerBlk = 32;
-    static const int RowsPerBlk = (TPB / ColsPerBlk) * RowsPerThread;
-    dim3 grid(raft::ceildiv(N, (IdxType)RowsPerBlk),
-              raft::ceildiv(D, (IdxType)ColsPerBlk));
-    CUDA_CHECK(cudaMemsetAsync(mu, 0, sizeof(Type) * D, stream));
-    meanKernelRowMajor<Type, IdxType, TPB, ColsPerBlk>
-      <<<grid, TPB, 0, stream>>>(mu, data, D, N);
-    CUDA_CHECK(cudaPeekAtLastError());
-    Type ratio = Type(1) / (sample ? Type(N - 1) : Type(N));
-    raft::linalg::scalarMultiply(mu, mu, ratio, D, stream);
-  } else {
-    meanKernelColMajor<Type, IdxType, TPB>
-      <<<D, TPB, 0, stream>>>(mu, data, D, N);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // namespace stats
-};  // namespace raft
diff --git a/cpp/src_prims/stats/mean_center.cuh b/cpp/src_prims/stats/mean_center.cuh
deleted file mode 100644
index 1cc614128e..0000000000
--- a/cpp/src_prims/stats/mean_center.cuh
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <vectorized.cuh>
-
-namespace raft {
-namespace stats {
-
-/**
- * @brief Center the input matrix wrt its mean
- * @tparam Type the data type
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads per block of the cuda kernel launched
- * @param out the output mean-centered matrix
- * @param data input matrix
- * @param mu the mean vector
- * @param D number of columns of data
- * @param N number of rows of data
- * @param rowMajor whether input is row or col major
- * @param bcastAlongRows whether to broadcast vector along rows or columns
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename IdxType = int, int TPB = 256>
-void meanCenter(Type *out, const Type *data, const Type *mu, IdxType D,
-                IdxType N, bool rowMajor, bool bcastAlongRows,
-                cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    out, data, mu, D, N, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a - b; }, stream);
-}
-
-/**
- * @brief Add the input matrix wrt its mean
- * @tparam Type the data type
- * @tparam IdxType Integer type used to for addressing
- * @tparam TPB threads per block of the cuda kernel launched
- * @param out the output mean-added matrix
- * @param data input matrix
- * @param mu the mean vector
- * @param D number of columns of data
- * @param N number of rows of data
- * @param rowMajor whether input is row or col major
- * @param bcastAlongRows whether to broadcast vector along rows or columns
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename IdxType = int, int TPB = 256>
-void meanAdd(Type *out, const Type *data, const Type *mu, IdxType D, IdxType N,
-             bool rowMajor, bool bcastAlongRows, cudaStream_t stream) {
-  raft::linalg::matrixVectorOp(
-    out, data, mu, D, N, rowMajor, bcastAlongRows,
-    [] __device__(Type a, Type b) { return a + b; }, stream);
-}
-
-};  // end namespace stats
-};  // end namespace raft
diff --git a/cpp/src_prims/stats/minmax.cuh b/cpp/src_prims/stats/minmax.cuh
index 4df62ece8f..98ffc3b820 100644
--- a/cpp/src_prims/stats/minmax.cuh
+++ b/cpp/src_prims/stats/minmax.cuh
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <limits>
+#include <raft/cuda_utils.cuh>
 
 namespace MLCommon {
 namespace Stats {
diff --git a/cpp/src_prims/stats/stddev.cuh b/cpp/src_prims/stats/stddev.cuh
deleted file mode 100644
index 7d64bc70cb..0000000000
--- a/cpp/src_prims/stats/stddev.cuh
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
-#include <raft/handle.hpp>
-
-namespace raft {
-namespace stats {
-
-///@todo: ColPerBlk has been tested only for 32!
-template <typename Type, typename IdxType, int TPB, int ColsPerBlk = 32>
-__global__ void stddevKernelRowMajor(Type *std, const Type *data, IdxType D,
-                                     IdxType N) {
-  const int RowsPerBlkPerIter = TPB / ColsPerBlk;
-  IdxType thisColId = threadIdx.x % ColsPerBlk;
-  IdxType thisRowId = threadIdx.x / ColsPerBlk;
-  IdxType colId = thisColId + ((IdxType)blockIdx.y * ColsPerBlk);
-  IdxType rowId = thisRowId + ((IdxType)blockIdx.x * RowsPerBlkPerIter);
-  Type thread_data = Type(0);
-  const IdxType stride = RowsPerBlkPerIter * gridDim.x;
-  for (IdxType i = rowId; i < N; i += stride) {
-    Type val = (colId < D) ? data[i * D + colId] : Type(0);
-    thread_data += val * val;
-  }
-  __shared__ Type sstd[ColsPerBlk];
-  if (threadIdx.x < ColsPerBlk) sstd[threadIdx.x] = Type(0);
-  __syncthreads();
-  raft::myAtomicAdd(sstd + thisColId, thread_data);
-  __syncthreads();
-  if (threadIdx.x < ColsPerBlk) raft::myAtomicAdd(std + colId, sstd[thisColId]);
-}
-
-template <typename Type, typename IdxType, int TPB>
-__global__ void stddevKernelColMajor(Type *std, const Type *data,
-                                     const Type *mu, IdxType D, IdxType N) {
-  typedef cub::BlockReduce<Type, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  Type thread_data = Type(0);
-  IdxType colStart = N * blockIdx.x;
-  Type m = mu[blockIdx.x];
-  for (IdxType i = threadIdx.x; i < N; i += TPB) {
-    IdxType idx = colStart + i;
-    Type diff = data[idx] - m;
-    thread_data += diff * diff;
-  }
-  Type acc = BlockReduce(temp_storage).Sum(thread_data);
-  if (threadIdx.x == 0) {
-    std[blockIdx.x] = raft::mySqrt(acc / N);
-  }
-}
-
-template <typename Type, typename IdxType, int TPB>
-__global__ void varsKernelColMajor(Type *var, const Type *data, const Type *mu,
-                                   IdxType D, IdxType N) {
-  typedef cub::BlockReduce<Type, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  Type thread_data = Type(0);
-  IdxType colStart = N * blockIdx.x;
-  Type m = mu[blockIdx.x];
-  for (IdxType i = threadIdx.x; i < N; i += TPB) {
-    IdxType idx = colStart + i;
-    Type diff = data[idx] - m;
-    thread_data += diff * diff;
-  }
-  Type acc = BlockReduce(temp_storage).Sum(thread_data);
-  if (threadIdx.x == 0) {
-    var[blockIdx.x] = acc / N;
-  }
-}
-
-/**
- * @brief Compute stddev of the input matrix
- *
- * Stddev operation is assumed to be performed on a given column.
- *
- * @tparam Type the data type
- * @tparam IdxType Integer type used to for addressing
- * @param std the output stddev vector
- * @param data the input matrix
- * @param mu the mean vector
- * @param D number of columns of data
- * @param N number of rows of data
- * @param sample whether to evaluate sample stddev or not. In other words,
- * whether
- *  to normalize the output using N-1 or N, for true or false, respectively
- * @param rowMajor whether the input data is row or col major
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename IdxType = int>
-void stddev(Type *std, const Type *data, const Type *mu, IdxType D, IdxType N,
-            bool sample, bool rowMajor, cudaStream_t stream) {
-  static const int TPB = 256;
-  if (rowMajor) {
-    static const int RowsPerThread = 4;
-    static const int ColsPerBlk = 32;
-    static const int RowsPerBlk = (TPB / ColsPerBlk) * RowsPerThread;
-    dim3 grid(raft::ceildiv(N, (IdxType)RowsPerBlk),
-              raft::ceildiv(D, (IdxType)ColsPerBlk));
-    CUDA_CHECK(cudaMemset(std, 0, sizeof(Type) * D));
-    stddevKernelRowMajor<Type, IdxType, TPB, ColsPerBlk>
-      <<<grid, TPB, 0, stream>>>(std, data, D, N);
-    Type ratio = Type(1) / (sample ? Type(N - 1) : Type(N));
-    raft::linalg::binaryOp(
-      std, std, mu, D,
-      [ratio] __device__(Type a, Type b) {
-        return raft::mySqrt(a * ratio - b * b);
-      },
-      stream);
-  } else {
-    stddevKernelColMajor<Type, IdxType, TPB>
-      <<<D, TPB, 0, stream>>>(std, data, mu, D, N);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-/**
- * @brief Compute variance of the input matrix
- *
- * Variance operation is assumed to be performed on a given column.
- *
- * @tparam Type the data type
- * @tparam IdxType Integer type used to for addressing
- * @param var the output stddev vector
- * @param data the input matrix
- * @param mu the mean vector
- * @param D number of columns of data
- * @param N number of rows of data
- * @param sample whether to evaluate sample stddev or not. In other words,
- * whether
- *  to normalize the output using N-1 or N, for true or false, respectively
- * @param rowMajor whether the input data is row or col major
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename IdxType = int>
-void vars(Type *var, const Type *data, const Type *mu, IdxType D, IdxType N,
-          bool sample, bool rowMajor, cudaStream_t stream) {
-  static const int TPB = 256;
-  if (rowMajor) {
-    static const int RowsPerThread = 4;
-    static const int ColsPerBlk = 32;
-    static const int RowsPerBlk = (TPB / ColsPerBlk) * RowsPerThread;
-    dim3 grid(raft::ceildiv(N, (IdxType)RowsPerBlk),
-              raft::ceildiv(D, (IdxType)ColsPerBlk));
-    CUDA_CHECK(cudaMemset(var, 0, sizeof(Type) * D));
-    stddevKernelRowMajor<Type, IdxType, TPB, ColsPerBlk>
-      <<<grid, TPB, 0, stream>>>(var, data, D, N);
-    Type ratio = Type(1) / (sample ? Type(N - 1) : Type(N));
-    raft::linalg::binaryOp(
-      var, var, mu, D,
-      [ratio] __device__(Type a, Type b) { return a * ratio - b * b; }, stream);
-  } else {
-    varsKernelColMajor<Type, IdxType, TPB>
-      <<<D, TPB, 0, stream>>>(var, data, mu, D, N);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // namespace stats
-};  // namespace raft
diff --git a/cpp/src_prims/stats/sum.cuh b/cpp/src_prims/stats/sum.cuh
deleted file mode 100644
index 89c8a60444..0000000000
--- a/cpp/src_prims/stats/sum.cuh
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <linalg/eltwise.cuh>
-
-namespace raft {
-namespace stats {
-
-///@todo: ColsPerBlk has been tested only for 32!
-template <typename Type, typename IdxType, int TPB, int ColsPerBlk = 32>
-__global__ void sumKernelRowMajor(Type *mu, const Type *data, IdxType D,
-                                  IdxType N) {
-  const int RowsPerBlkPerIter = TPB / ColsPerBlk;
-  IdxType thisColId = threadIdx.x % ColsPerBlk;
-  IdxType thisRowId = threadIdx.x / ColsPerBlk;
-  IdxType colId = thisColId + ((IdxType)blockIdx.y * ColsPerBlk);
-  IdxType rowId = thisRowId + ((IdxType)blockIdx.x * RowsPerBlkPerIter);
-  Type thread_data = Type(0);
-  const IdxType stride = RowsPerBlkPerIter * gridDim.x;
-  for (IdxType i = rowId; i < N; i += stride)
-    thread_data += (colId < D) ? data[i * D + colId] : Type(0);
-  __shared__ Type smu[ColsPerBlk];
-  if (threadIdx.x < ColsPerBlk) smu[threadIdx.x] = Type(0);
-  __syncthreads();
-  raft::myAtomicAdd(smu + thisColId, thread_data);
-  __syncthreads();
-  if (threadIdx.x < ColsPerBlk) raft::myAtomicAdd(mu + colId, smu[thisColId]);
-}
-
-template <typename Type, typename IdxType, int TPB>
-__global__ void sumKernelColMajor(Type *mu, const Type *data, IdxType D,
-                                  IdxType N) {
-  typedef cub::BlockReduce<Type, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  Type thread_data = Type(0);
-  IdxType colStart = N * blockIdx.x;
-  for (IdxType i = threadIdx.x; i < N; i += TPB) {
-    IdxType idx = colStart + i;
-    thread_data += data[idx];
-  }
-  Type acc = BlockReduce(temp_storage).Sum(thread_data);
-  if (threadIdx.x == 0) {
-    mu[blockIdx.x] = acc;
-  }
-}
-
-/**
- * @brief Compute sum of the input matrix
- *
- * Sum operation is assumed to be performed on a given column.
- *
- * @tparam Type the data type
- * @tparam IdxType Integer type used to for addressing
- * @param output the output mean vector
- * @param input the input matrix
- * @param D number of columns of data
- * @param N number of rows of data
- * @param rowMajor whether the input data is row or col major
- * @param stream cuda stream where to launch work
- */
-template <typename Type, typename IdxType = int>
-void sum(Type *output, const Type *input, IdxType D, IdxType N, bool rowMajor,
-         cudaStream_t stream) {
-  static const int TPB = 256;
-  if (rowMajor) {
-    static const int RowsPerThread = 4;
-    static const int ColsPerBlk = 32;
-    static const int RowsPerBlk = (TPB / ColsPerBlk) * RowsPerThread;
-    dim3 grid(raft::ceildiv(N, (IdxType)RowsPerBlk),
-              raft::ceildiv(D, (IdxType)ColsPerBlk));
-    CUDA_CHECK(cudaMemset(output, 0, sizeof(Type) * D));
-    sumKernelRowMajor<Type, IdxType, TPB, ColsPerBlk>
-      <<<grid, TPB, 0, stream>>>(output, input, D, N);
-  } else {
-    sumKernelColMajor<Type, IdxType, TPB>
-      <<<D, TPB, 0, stream>>>(output, input, D, N);
-  }
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-};  // end namespace stats
-};  // end namespace raft
diff --git a/cpp/src_prims/stats/weighted_mean.cuh b/cpp/src_prims/stats/weighted_mean.cuh
index c4e4f7573a..b02b306cc1 100644
--- a/cpp/src_prims/stats/weighted_mean.cuh
+++ b/cpp/src_prims/stats/weighted_mean.cuh
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
-#include <linalg/coalesced_reduction.cuh>
-#include <linalg/strided_reduction.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/coalesced_reduction.cuh>
+#include <raft/linalg/strided_reduction.cuh>
 
 namespace MLCommon {
 namespace Stats {
diff --git a/cpp/src_prims/timeSeries/arima_helpers.cuh b/cpp/src_prims/timeSeries/arima_helpers.cuh
index 6583108301..e4456eb205 100644
--- a/cpp/src_prims/timeSeries/arima_helpers.cuh
+++ b/cpp/src_prims/timeSeries/arima_helpers.cuh
@@ -18,12 +18,12 @@
 
 #include <cuda_runtime.h>
 
-#include <common/cudart_utils.h>
 #include <cuml/tsa/arima_common.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <linalg/batched/matrix.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include "jones_transform.cuh"
 
 namespace MLCommon {
diff --git a/cpp/src_prims/timeSeries/jones_transform.cuh b/cpp/src_prims/timeSeries/jones_transform.cuh
index 7c75838315..5d37bd15ae 100644
--- a/cpp/src_prims/timeSeries/jones_transform.cuh
+++ b/cpp/src_prims/timeSeries/jones_transform.cuh
@@ -21,12 +21,12 @@
 
 #pragma once
 
-#include <common/cudart_utils.h>
 #include <math.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/unary_op.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/unary_op.cuh>
 
 namespace MLCommon {
 
diff --git a/cpp/src_prims/timeSeries/stationarity.cuh b/cpp/src_prims/timeSeries/stationarity.cuh
index 19f3a59b4a..1afa4fb275 100644
--- a/cpp/src_prims/timeSeries/stationarity.cuh
+++ b/cpp/src_prims/timeSeries/stationarity.cuh
@@ -33,13 +33,13 @@
 #include <thrust/scan.h>
 #include <vector>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <common/device_buffer.hpp>
 #include <cuml/common/cuml_allocator.hpp>
-#include <linalg/matrix_vector_op.cuh>
-#include <linalg/reduce.cuh>
-#include <stats/mean.cuh>
+#include <raft/linalg/matrix_vector_op.cuh>
+#include <raft/linalg/reduce.cuh>
+#include <raft/stats/mean.cuh>
 #include <timeSeries/arima_helpers.cuh>
 
 namespace MLCommon {
diff --git a/cpp/src_prims/vectorized.cuh b/cpp/src_prims/vectorized.cuh
deleted file mode 100644
index 1829fc0351..0000000000
--- a/cpp/src_prims/vectorized.cuh
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * Copyright (c) 2018, 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 <cuda_fp16.h>
-#include "cuda_utils.cuh"
-
-namespace raft {
-
-template <typename math_, int VecLen>
-struct IOType {};
-template <>
-struct IOType<bool, 1> {
-  static_assert(sizeof(bool) == sizeof(int8_t),
-                "IOType bool size assumption failed");
-  typedef int8_t Type;
-};
-template <>
-struct IOType<bool, 2> {
-  typedef int16_t Type;
-};
-template <>
-struct IOType<bool, 4> {
-  typedef int32_t Type;
-};
-template <>
-struct IOType<bool, 8> {
-  typedef int2 Type;
-};
-template <>
-struct IOType<bool, 16> {
-  typedef int4 Type;
-};
-template <>
-struct IOType<int8_t, 1> {
-  typedef int8_t Type;
-};
-template <>
-struct IOType<int8_t, 2> {
-  typedef int16_t Type;
-};
-template <>
-struct IOType<int8_t, 4> {
-  typedef int32_t Type;
-};
-template <>
-struct IOType<int8_t, 8> {
-  typedef int2 Type;
-};
-template <>
-struct IOType<int8_t, 16> {
-  typedef int4 Type;
-};
-template <>
-struct IOType<uint8_t, 1> {
-  typedef uint8_t Type;
-};
-template <>
-struct IOType<uint8_t, 2> {
-  typedef uint16_t Type;
-};
-template <>
-struct IOType<uint8_t, 4> {
-  typedef uint32_t Type;
-};
-template <>
-struct IOType<uint8_t, 8> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<uint8_t, 16> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<int16_t, 1> {
-  typedef int16_t Type;
-};
-template <>
-struct IOType<int16_t, 2> {
-  typedef int32_t Type;
-};
-template <>
-struct IOType<int16_t, 4> {
-  typedef int2 Type;
-};
-template <>
-struct IOType<int16_t, 8> {
-  typedef int4 Type;
-};
-template <>
-struct IOType<uint16_t, 1> {
-  typedef uint16_t Type;
-};
-template <>
-struct IOType<uint16_t, 2> {
-  typedef uint32_t Type;
-};
-template <>
-struct IOType<uint16_t, 4> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<uint16_t, 8> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<__half, 1> {
-  typedef __half Type;
-};
-template <>
-struct IOType<__half, 2> {
-  typedef __half2 Type;
-};
-template <>
-struct IOType<__half, 4> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<__half, 8> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<__half2, 1> {
-  typedef __half2 Type;
-};
-template <>
-struct IOType<__half2, 2> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<__half2, 4> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<int32_t, 1> {
-  typedef int32_t Type;
-};
-template <>
-struct IOType<int32_t, 2> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<int32_t, 4> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<uint32_t, 1> {
-  typedef uint32_t Type;
-};
-template <>
-struct IOType<uint32_t, 2> {
-  typedef uint2 Type;
-};
-template <>
-struct IOType<uint32_t, 4> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<float, 1> {
-  typedef float Type;
-};
-template <>
-struct IOType<float, 2> {
-  typedef float2 Type;
-};
-template <>
-struct IOType<float, 4> {
-  typedef float4 Type;
-};
-template <>
-struct IOType<int64_t, 1> {
-  typedef int64_t Type;
-};
-template <>
-struct IOType<int64_t, 2> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<uint64_t, 1> {
-  typedef uint64_t Type;
-};
-template <>
-struct IOType<uint64_t, 2> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<unsigned long long, 1> {
-  typedef unsigned long long Type;
-};
-template <>
-struct IOType<unsigned long long, 2> {
-  typedef uint4 Type;
-};
-template <>
-struct IOType<double, 1> {
-  typedef double Type;
-};
-template <>
-struct IOType<double, 2> {
-  typedef double2 Type;
-};
-
-/**
-     * @struct TxN_t
-     *
-     * @brief Internal data structure that is used to define a facade for vectorized
-     * loads/stores across the most common POD types. The goal of his file is to
-     * provide with CUDA programmers, an easy way to have compiler issue vectorized
-     * load or store instructions to memory (either global or shared). Vectorized
-     * accesses to memory are important as they'll utilize its resources
-     * efficiently,
-     * when compared to their non-vectorized counterparts. Obviously, for whatever
-     * reasons if one is unable to issue such vectorized operations, one can always
-     * fallback to using POD types.
-     *
-     * Example demonstrating the use of load operations, performing math on such
-     * loaded data and finally storing it back.
-     * @code{.cu}
-     * TxN_t<uint8_t,8> mydata1, mydata2;
-     * int idx = (threadIdx.x + (blockIdx.x * blockDim.x)) * mydata1.Ratio;
-     * mydata1.load(ptr1, idx);
-     * mydata2.load(ptr2, idx);
-     * #pragma unroll
-     * for(int i=0;i<mydata1.Ratio;++i) {
-     *     mydata1.val.data[i] += mydata2.val.data[i];
-     * }
-     * mydata1.store(ptr1, idx);
-     * @endcode
-     *
-     * By doing as above, the interesting thing is that the code effectively remains
-     * almost the same, in case one wants to upgrade to TxN_t<uint16_t,16> type.
-     * Only change required is to replace variable declaration appropriately.
-     *
-     * Obviously, it's caller's responsibility to take care of pointer alignment!
-     *
-     * @tparam math_ the data-type in which the compute/math needs to happen
-     * @tparam veclen_ the number of 'math_' types to be loaded/stored per
-     * instruction
-     */
-template <typename math_, int veclen_>
-struct TxN_t {
-  /** underlying math data type */
-  typedef math_ math_t;
-  /** internal storage data type */
-  typedef typename IOType<math_t, veclen_>::Type io_t;
-
-  /** defines the number of 'math_t' types stored by this struct */
-  static const int Ratio = veclen_;
-
-  union {
-    /** the vectorized data that is used for subsequent operations */
-    math_t data[Ratio];
-    /** internal data used to ensure vectorized loads/stores */
-    io_t internal;
-  } val;
-
-  ///@todo: add default constructor
-
-  /**
-   * @brief Fill the contents of this structure with a constant value
-   * @param _val the constant to be filled
-   */
-  DI void fill(math_t _val) {
-#pragma unroll
-    for (int i = 0; i < Ratio; ++i) {
-      val.data[i] = _val;
-    }
-  }
-
-  ///@todo: how to handle out-of-bounds!!?
-
-  /**
-   * @defgroup LoadsStores Global/Shared vectored loads or stores
-   *
-   * @brief Perform vectored loads/stores on this structure
-   * @tparam idx_t index data type
-   * @param ptr base pointer from where to load (or store) the data. It must
-   *  be aligned to 'sizeof(io_t)'!
-   * @param idx the offset from the base pointer which will be loaded
-   *  (or stored) by the current thread. This must be aligned to 'Ratio'!
-   *
-   * @note: In case of loads, after a successful execution, the val.data will
-   *  be populated with the desired data loaded from the pointer location. In
-   * case of stores, the data in the val.data will be stored to that location.
-   * @{
-   */
-  template <typename idx_t = int>
-  DI void load(const math_t *ptr, idx_t idx) {
-    const io_t *bptr = reinterpret_cast<const io_t *>(&ptr[idx]);
-    val.internal = __ldg(bptr);
-  }
-
-  template <typename idx_t = int>
-  DI void load(math_t *ptr, idx_t idx) {
-    io_t *bptr = reinterpret_cast<io_t *>(&ptr[idx]);
-    val.internal = *bptr;
-  }
-
-  template <typename idx_t = int>
-  DI void store(math_t *ptr, idx_t idx) {
-    io_t *bptr = reinterpret_cast<io_t *>(&ptr[idx]);
-    *bptr = val.internal;
-  }
-  /** @} */
-};
-
-/** this is just to keep the compiler happy! */
-template <typename math_>
-struct TxN_t<math_, 0> {
-  typedef math_ math_t;
-  static const int Ratio = 1;
-
-  union {
-    math_t data[1];
-  } val;
-
-  DI void fill(math_t _val) {}
-  template <typename idx_t = int>
-  DI void load(const math_t *ptr, idx_t idx) {}
-  template <typename idx_t = int>
-  DI void load(math_t *ptr, idx_t idx) {}
-  template <typename idx_t = int>
-  DI void store(math_t *ptr, idx_t idx) {}
-};
-
-}  // namespace raft
diff --git a/cpp/test/CMakeLists.txt b/cpp/test/CMakeLists.txt
index 851aaa65a5..db7bc0de48 100644
--- a/cpp/test/CMakeLists.txt
+++ b/cpp/test/CMakeLists.txt
@@ -123,7 +123,6 @@ endif(BUILD_CUML_MG_TESTS)
 if(BUILD_PRIMS_TESTS)
   # (please keep the filenames in alphabetical order)
   add_executable(prims
-    prims/add.cu
     prims/add_sub_dev_scalar.cu
     prims/adjustedRandIndex.cu
     prims/batched/csr.cu
@@ -131,17 +130,14 @@ if(BUILD_PRIMS_TESTS)
     prims/batched/information_criterion.cu
     prims/batched/make_symm.cu
     prims/batched/matrix.cu
-    prims/binary_op.cu
-    prims/ternary_op.cu
     prims/cache.cu
-    prims/coalesced_reduction.cu
-    prims/cuda_utils.cu
     prims/columnSort.cu
     prims/completenessScore.cu
     prims/contingencyMatrix.cu
     prims/coo.cu
     prims/cov.cu
     prims/csr.cu
+    prims/cutlass_gemm.cu
     prims/decoupled_lookback.cu
     prims/device_utils.cu
     prims/dispersion.cu
@@ -150,18 +146,12 @@ if(BUILD_PRIMS_TESTS)
     prims/dist_euc_exp.cu
     prims/dist_euc_unexp.cu
     prims/dist_l1.cu
-    prims/divide.cu
-    prims/eig.cu
-    prims/eig_sel.cu
-    prims/eltwise.cu
     prims/eltwise2d.cu
     prims/entropy.cu
     prims/epsilon_neighborhood.cu
     prims/fast_int_div.cu
     prims/fused_l2_nn.cu
     prims/gather.cu
-    prims/gemm.cu
-    prims/gemm_layout.cu
     prims/gram.cu
     prims/grid_sync.cu
     prims/hinge.cu
@@ -181,44 +171,24 @@ if(BUILD_PRIMS_TESTS)
     prims/make_arima.cu
     prims/make_blobs.cu
     prims/make_regression.cu
-    prims/map_then_reduce.cu
-    prims/math.cu
-    prims/matrix.cu
-    prims/matrix_vector_op.cu
-    prims/mean.cu
-    prims/mean_center.cu
     prims/minmax.cu
     prims/mvg.cu
-    prims/multiply.cu
     prims/mutualInfoScore.cu
-    prims/norm.cu
     prims/penalty.cu
     prims/permute.cu
     prims/power.cu
     prims/randIndex.cu
-    prims/reduce.cu
     prims/reduce_cols_by_key.cu
     prims/reduce_rows_by_key.cu
     prims/reverse.cu
-    prims/rng.cu
-    prims/rng_int.cu
     prims/rsvd.cu
-    prims/sample_without_replacement.cu
-    prims/scatter.cu
     prims/score.cu
     prims/seive.cu
     prims/sigmoid.cu
     prims/silhouetteScore.cu
     prims/sqrt.cu
-    prims/stddev.cu
-    prims/strided_reduction.cu
-    prims/subtract.cu
-    prims/sum.cu
-    prims/svd.cu
     prims/ternary_op.cu
-    prims/transpose.cu
     prims/trustworthiness.cu
-    prims/unary_op.cu
     prims/vMeasure.cu
     prims/weighted_mean.cu
     ../src/common/logger.cpp)  # because prims is header only!
diff --git a/cpp/test/mg/knn.cu b/cpp/test/mg/knn.cu
index a91f86a5cd..d72dc3d436 100644
--- a/cpp/test/mg/knn.cu
+++ b/cpp/test/mg/knn.cu
@@ -27,7 +27,7 @@
 
 #include <common/cumlHandle.hpp>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace KNN {
diff --git a/cpp/test/mg/knn_test_helper.cuh b/cpp/test/mg/knn_test_helper.cuh
index f0652843d7..7a3000b696 100644
--- a/cpp/test/mg/knn_test_helper.cuh
+++ b/cpp/test/mg/knn_test_helper.cuh
@@ -31,7 +31,7 @@
 
 #include <common/cumlHandle.hpp>
 
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace KNN {
diff --git a/cpp/test/mg/pca.cu b/cpp/test/mg/pca.cu
index 25d928d1a8..b70e83412a 100644
--- a/cpp/test/mg/pca.cu
+++ b/cpp/test/mg/pca.cu
@@ -14,16 +14,17 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
+#include <common/device_buffer.hpp>
 #include <cuml/common/logger.hpp>
 #include <cuml/decomposition/pca_mg.hpp>
-#include <matrix/matrix.cuh>
 #include <opg/linalg/gemm.hpp>
 #include <opg/matrix/matrix_utils.hpp>
+#include <raft/cuda_utils.cuh>
+#include <raft/matrix/matrix.cuh>
 #include "test_opg_utils.h"
 
 #include <common/cumlHandle.hpp>
diff --git a/cpp/test/mg/test_opg_utils.h b/cpp/test/mg/test_opg_utils.h
index 42f3907d85..a30e657a4f 100644
--- a/cpp/test/mg/test_opg_utils.h
+++ b/cpp/test/mg/test_opg_utils.h
@@ -18,7 +18,7 @@
 
 #include <gtest/gtest.h>
 #include <mpi.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 
 #include <common/cumlHandle.hpp>
 
diff --git a/cpp/test/prims/add.cu b/cpp/test/prims/add.cu
deleted file mode 100644
index dec3e66d49..0000000000
--- a/cpp/test/prims/add.cu
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/add.cuh>
-#include <random/rng.cuh>
-#include "add.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename InT, typename OutT = InT>
-class AddTest : public ::testing::TestWithParam<AddInputs<InT, OutT>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<AddInputs<InT, OutT>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(in1, len);
-    raft::allocate(in2, len);
-    raft::allocate(out_ref, len);
-    raft::allocate(out, len);
-    r.uniform(in1, len, InT(-1.0), InT(1.0), stream);
-    r.uniform(in2, len, InT(-1.0), InT(1.0), stream);
-    naiveAddElem<InT, OutT>(out_ref, in1, in2, len);
-    add<InT, OutT>(out, in1, in2, len, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    CUDA_CHECK(cudaFree(in1));
-    CUDA_CHECK(cudaFree(in2));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void compare() {
-    ASSERT_TRUE(raft::devArrMatch(out_ref, out, params.len,
-                                  raft::CompareApprox<OutT>(params.tolerance)));
-  }
-
- protected:
-  AddInputs<InT, OutT> params;
-  InT *in1, *in2;
-  OutT *out_ref, *out;
-  cudaStream_t stream;
-};
-
-const std::vector<AddInputs<float>> inputsf = {
-  {0.000001f, 1024 * 1024, 1234ULL},
-  {0.000001f, 1024 * 1024 + 2, 1234ULL},
-  {0.000001f, 1024 * 1024 + 1, 1234ULL},
-};
-typedef AddTest<float> AddTestF;
-TEST_P(AddTestF, Result) { compare(); }
-INSTANTIATE_TEST_CASE_P(AddTests, AddTestF, ::testing::ValuesIn(inputsf));
-
-const std::vector<AddInputs<double>> inputsd = {
-  {0.00000001, 1024 * 1024, 1234ULL},
-  {0.00000001, 1024 * 1024 + 2, 1234ULL},
-  {0.00000001, 1024 * 1024 + 1, 1234ULL},
-};
-typedef AddTest<double> AddTestD;
-TEST_P(AddTestD, Result) { compare(); }
-INSTANTIATE_TEST_CASE_P(AddTests, AddTestD, ::testing::ValuesIn(inputsd));
-
-const std::vector<AddInputs<float, double>> inputsfd = {
-  {0.00000001, 1024 * 1024, 1234ULL},
-  {0.00000001, 1024 * 1024 + 2, 1234ULL},
-  {0.00000001, 1024 * 1024 + 1, 1234ULL},
-};
-typedef AddTest<float, double> AddTestFD;
-TEST_P(AddTestFD, Result) { compare(); }
-INSTANTIATE_TEST_CASE_P(AddTests, AddTestFD, ::testing::ValuesIn(inputsfd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/add.cuh b/cpp/test/prims/add.cuh
deleted file mode 100644
index 8dc62df7b2..0000000000
--- a/cpp/test/prims/add.cuh
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <linalg/add.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename InT, typename OutT = InT>
-__global__ void naiveAddElemKernel(OutT *out, const InT *in1, const InT *in2,
-                                   int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = OutT(in1[idx] + in2[idx]);
-  }
-}
-
-template <typename InT, typename OutT = InT>
-void naiveAddElem(OutT *out, const InT *in1, const InT *in2, int len) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveAddElemKernel<InT, OutT><<<nblks, TPB>>>(out, in1, in2, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename InT, typename OutT = InT>
-struct AddInputs {
-  OutT tolerance;
-  int len;
-  unsigned long long int seed;
-};
-
-template <typename InT, typename OutT = InT>
-::std::ostream &operator<<(::std::ostream &os,
-                           const AddInputs<InT, OutT> &dims) {
-  return os;
-}
-
-};  // end namespace linalg
-};  // end namespace raft
diff --git a/cpp/test/prims/add_sub_dev_scalar.cu b/cpp/test/prims/add_sub_dev_scalar.cu
index 7538e1c189..f56cd8e626 100644
--- a/cpp/test/prims/add_sub_dev_scalar.cu
+++ b/cpp/test/prims/add_sub_dev_scalar.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <linalg/add.cuh>
-#include <linalg/subtract.cuh>
-#include <linalg/unary_op.cuh>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/add.cuh>
+#include <raft/linalg/subtract.cuh>
+#include <raft/linalg/unary_op.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace raft {
diff --git a/cpp/test/prims/adjustedRandIndex.cu b/cpp/test/prims/adjustedRandIndex.cu
index 53e5f23ace..a82f4272a3 100644
--- a/cpp/test/prims/adjustedRandIndex.cu
+++ b/cpp/test/prims/adjustedRandIndex.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/batched/csr.cu b/cpp/test/prims/batched/csr.cu
index 48f93bd2fe..2d91f456c3 100644
--- a/cpp/test/prims/batched/csr.cu
+++ b/cpp/test/prims/batched/csr.cu
@@ -20,8 +20,8 @@
 #include <random>
 #include <vector>
 
-#include <common/cudart_utils.h>
 #include <linalg_naive.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <linalg/batched/matrix.cuh>
 #include <sparse/batched/csr.cuh>
diff --git a/cpp/test/prims/batched/gemv.cu b/cpp/test/prims/batched/gemv.cu
index e42a071f17..182781a919 100644
--- a/cpp/test/prims/batched/gemv.cu
+++ b/cpp/test/prims/batched/gemv.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <linalg/batched/gemv.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "../test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/batched/information_criterion.cu b/cpp/test/prims/batched/information_criterion.cu
index da620ddc52..9d0c6585ab 100644
--- a/cpp/test/prims/batched/information_criterion.cu
+++ b/cpp/test/prims/batched/information_criterion.cu
@@ -21,7 +21,7 @@
 #include <random>
 #include <vector>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <metrics/batched/information_criterion.cuh>
 #include "../test_utils.h"
diff --git a/cpp/test/prims/batched/make_symm.cu b/cpp/test/prims/batched/make_symm.cu
index fd068ca1a9..d751099687 100644
--- a/cpp/test/prims/batched/make_symm.cu
+++ b/cpp/test/prims/batched/make_symm.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <linalg/batched/make_symm.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "../test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/batched/matrix.cu b/cpp/test/prims/batched/matrix.cu
index 1b2ae54969..0e114546cc 100644
--- a/cpp/test/prims/batched/matrix.cu
+++ b/cpp/test/prims/batched/matrix.cu
@@ -23,10 +23,10 @@
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/cuml.hpp>
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <linalg/batched/matrix.cuh>
-#include "../add.cuh"
+#include <raft/linalg/add.cuh>
 #include "../linalg_naive.h"
 #include "../test_utils.h"
 
diff --git a/cpp/test/prims/binary_op.cu b/cpp/test/prims/binary_op.cu
deleted file mode 100644
index e36720b065..0000000000
--- a/cpp/test/prims/binary_op.cu
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/binary_op.cuh>
-#include <random/rng.cuh>
-#include "binary_op.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename InType, typename IdxType, typename OutType>
-void binaryOpLaunch(OutType *out, const InType *in1, const InType *in2,
-                    IdxType len, cudaStream_t stream) {
-  binaryOp(
-    out, in1, in2, len, [] __device__(InType a, InType b) { return a + b; },
-    stream);
-}
-
-template <typename InType, typename IdxType, typename OutType = InType>
-class BinaryOpTest
-  : public ::testing::TestWithParam<BinaryOpInputs<InType, IdxType, OutType>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<
-      BinaryOpInputs<InType, IdxType, OutType>>::GetParam();
-    raft::random::Rng r(params.seed);
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    IdxType len = params.len;
-    allocate(in1, len);
-    allocate(in2, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    r.uniform(in1, len, InType(-1.0), InType(1.0), stream);
-    r.uniform(in2, len, InType(-1.0), InType(1.0), stream);
-    naiveAdd(out_ref, in1, in2, len);
-    binaryOpLaunch(out, in1, in2, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in1));
-    CUDA_CHECK(cudaFree(in2));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  BinaryOpInputs<InType, IdxType, OutType> params;
-  InType *in1, *in2;
-  OutType *out_ref, *out;
-};
-
-const std::vector<BinaryOpInputs<float, int>> inputsf_i32 = {
-  {0.000001f, 1024 * 1024, 1234ULL}};
-typedef BinaryOpTest<float, int> BinaryOpTestF_i32;
-TEST_P(BinaryOpTestF_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(BinaryOpTests, BinaryOpTestF_i32,
-                        ::testing::ValuesIn(inputsf_i32));
-
-const std::vector<BinaryOpInputs<float, size_t>> inputsf_i64 = {
-  {0.000001f, 1024 * 1024, 1234ULL}};
-typedef BinaryOpTest<float, size_t> BinaryOpTestF_i64;
-TEST_P(BinaryOpTestF_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(BinaryOpTests, BinaryOpTestF_i64,
-                        ::testing::ValuesIn(inputsf_i64));
-
-const std::vector<BinaryOpInputs<float, int, double>> inputsf_i32_d = {
-  {0.000001f, 1024 * 1024, 1234ULL}};
-typedef BinaryOpTest<float, int, double> BinaryOpTestF_i32_D;
-TEST_P(BinaryOpTestF_i32_D, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(BinaryOpTests, BinaryOpTestF_i32_D,
-                        ::testing::ValuesIn(inputsf_i32_d));
-
-const std::vector<BinaryOpInputs<double, int>> inputsd_i32 = {
-  {0.00000001, 1024 * 1024, 1234ULL}};
-typedef BinaryOpTest<double, int> BinaryOpTestD_i32;
-TEST_P(BinaryOpTestD_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(BinaryOpTests, BinaryOpTestD_i32,
-                        ::testing::ValuesIn(inputsd_i32));
-
-const std::vector<BinaryOpInputs<double, size_t>> inputsd_i64 = {
-  {0.00000001, 1024 * 1024, 1234ULL}};
-typedef BinaryOpTest<double, size_t> BinaryOpTestD_i64;
-TEST_P(BinaryOpTestD_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(BinaryOpTests, BinaryOpTestD_i64,
-                        ::testing::ValuesIn(inputsd_i64));
-
-}  // namespace linalg
-}  // namespace raft
diff --git a/cpp/test/prims/binary_op.cuh b/cpp/test/prims/binary_op.cuh
deleted file mode 100644
index 711b007b20..0000000000
--- a/cpp/test/prims/binary_op.cuh
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <linalg/binary_op.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename InType, typename OutType, typename IdxType>
-__global__ void naiveAddKernel(OutType *out, const InType *in1,
-                               const InType *in2, IdxType len) {
-  IdxType idx = threadIdx.x + ((IdxType)blockIdx.x * (IdxType)blockDim.x);
-  if (idx < len) {
-    out[idx] = static_cast<OutType>(in1[idx] + in2[idx]);
-  }
-}
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-void naiveAdd(OutType *out, const InType *in1, const InType *in2, IdxType len) {
-  static const IdxType TPB = 64;
-  IdxType nblks = raft::ceildiv(len, TPB);
-  naiveAddKernel<InType, OutType, IdxType><<<nblks, TPB>>>(out, in1, in2, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-struct BinaryOpInputs {
-  InType tolerance;
-  IdxType len;
-  unsigned long long int seed;
-};
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-::std::ostream &operator<<(::std::ostream &os,
-                           const BinaryOpInputs<InType, IdxType, OutType> &d) {
-  return os;
-}
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/cache.cu b/cpp/test/prims/cache.cu
index 5fa657ec71..b3dc54812c 100644
--- a/cpp/test/prims/cache.cu
+++ b/cpp/test/prims/cache.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <cache/cache.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/coalesced_reduction.cu b/cpp/test/prims/coalesced_reduction.cu
deleted file mode 100644
index 02eb3c04d3..0000000000
--- a/cpp/test/prims/coalesced_reduction.cu
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/coalesced_reduction.cuh>
-#include <random/rng.cuh>
-#include "reduce.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct coalescedReductionInputs {
-  T tolerance;
-  int rows, cols;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os,
-                           const coalescedReductionInputs<T> &dims) {
-  return os;
-}
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename T>
-void coalescedReductionLaunch(T *dots, const T *data, int cols, int rows,
-                              cudaStream_t stream, bool inplace = false) {
-  coalescedReduction(dots, data, cols, rows, (T)0, stream, inplace,
-                     [] __device__(T in, int i) { return in * in; });
-}
-
-template <typename T>
-class coalescedReductionTest
-  : public ::testing::TestWithParam<coalescedReductionInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<coalescedReductionInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(data, len);
-    raft::allocate(dots_exp, rows);
-    raft::allocate(dots_act, rows);
-    r.uniform(data, len, T(-1.0), T(1.0), stream);
-    naiveCoalescedReduction(dots_exp, data, cols, rows, stream);
-
-    // Perform reduction with default inplace = false first
-    coalescedReductionLaunch(dots_act, data, cols, rows, stream);
-    // Add to result with inplace = true next
-    coalescedReductionLaunch(dots_act, data, cols, rows, stream, true);
-
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(dots_exp));
-    CUDA_CHECK(cudaFree(dots_act));
-  }
-
- protected:
-  coalescedReductionInputs<T> params;
-  T *data, *dots_exp, *dots_act;
-};
-
-const std::vector<coalescedReductionInputs<float>> inputsf = {
-  {0.000002f, 1024, 32, 1234ULL},
-  {0.000002f, 1024, 64, 1234ULL},
-  {0.000002f, 1024, 128, 1234ULL},
-  {0.000002f, 1024, 256, 1234ULL}};
-
-const std::vector<coalescedReductionInputs<double>> inputsd = {
-  {0.000000001, 1024, 32, 1234ULL},
-  {0.000000001, 1024, 64, 1234ULL},
-  {0.000000001, 1024, 128, 1234ULL},
-  {0.000000001, 1024, 256, 1234ULL}};
-
-typedef coalescedReductionTest<float> coalescedReductionTestF;
-TEST_P(coalescedReductionTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.rows,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef coalescedReductionTest<double> coalescedReductionTestD;
-TEST_P(coalescedReductionTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.rows,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(coalescedReductionTests, coalescedReductionTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(coalescedReductionTests, coalescedReductionTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/columnSort.cu b/cpp/test/prims/columnSort.cu
index 92770f71b8..8c240fb4fc 100644
--- a/cpp/test/prims/columnSort.cu
+++ b/cpp/test/prims/columnSort.cu
@@ -14,8 +14,8 @@
 * limitations under the License.
 */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <numeric>
 #include <selection/columnWiseSort.cuh>
diff --git a/cpp/test/prims/completenessScore.cu b/cpp/test/prims/completenessScore.cu
index d7a99d1ad7..6dad55e2f7 100644
--- a/cpp/test/prims/completenessScore.cu
+++ b/cpp/test/prims/completenessScore.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/contingencyMatrix.cu b/cpp/test/prims/contingencyMatrix.cu
index f4d03b7232..0ebdb108bf 100644
--- a/cpp/test/prims/contingencyMatrix.cu
+++ b/cpp/test/prims/contingencyMatrix.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <iostream>
 #include <metrics/contingencyMatrix.cuh>
diff --git a/cpp/test/prims/coo.cu b/cpp/test/prims/coo.cu
index 2cbe7e3340..812724a105 100644
--- a/cpp/test/prims/coo.cu
+++ b/cpp/test/prims/coo.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
 #include <sparse/coo.cuh>
 #include "coo.h"
 #include "test_utils.h"
diff --git a/cpp/test/prims/cov.cu b/cpp/test/prims/cov.cu
index e545ae6978..6c5705e45c 100644
--- a/cpp/test/prims/cov.cu
+++ b/cpp/test/prims/cov.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
+#include <raft/stats/mean.cuh>
 #include <stats/cov.cuh>
-#include <stats/mean.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/csr.cu b/cpp/test/prims/csr.cu
index c04982fd76..a9ac48a9d0 100644
--- a/cpp/test/prims/csr.cu
+++ b/cpp/test/prims/csr.cu
@@ -18,8 +18,8 @@
 #include <sparse/csr.cuh>
 #include "csr.h"
 
-#include <common/cudart_utils.h>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 #include <iostream>
diff --git a/cpp/test/prims/cuda_utils.cu b/cpp/test/prims/cuda_utils.cu
deleted file mode 100644
index be0d5e9e89..0000000000
--- a/cpp/test/prims/cuda_utils.cu
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <gtest/gtest.h>
-#include <cuda_utils.cuh>
-
-namespace raft {
-
-TEST(Utils, Assert) {
-  ASSERT_NO_THROW(ASSERT(1 == 1, "Should not assert!"));
-  ASSERT_THROW(ASSERT(1 != 1, "Should assert!"), raft::exception);
-}
-
-TEST(Utils, CudaCheck) { ASSERT_NO_THROW(CUDA_CHECK(cudaFree(nullptr))); }
-
-// we want the functions like 'log2' to work both at compile and runtimes!
-static const int log2Of1024 = log2(1024);
-static const int log2Of1023 = log2(1023);
-TEST(Utils, log2) {
-  ASSERT_EQ(10, log2(1024));
-  ASSERT_EQ(9, log2(1023));
-  ASSERT_EQ(10, log2Of1024);
-  ASSERT_EQ(9, log2Of1023);
-}
-
-}  // end namespace raft
diff --git a/cpp/test/prims/gemm.cu b/cpp/test/prims/cutlass_gemm.cu
similarity index 97%
rename from cpp/test/prims/gemm.cu
rename to cpp/test/prims/cutlass_gemm.cu
index d8bbf4bfe6..1bd6d709df 100644
--- a/cpp/test/prims/gemm.cu
+++ b/cpp/test/prims/cutlass_gemm.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <linalg/gemm.cuh>
+#include <raft/cudart_utils.h>
+#include <linalg/cutlass_gemm.cuh>
 
 namespace MLCommon {
 namespace LinAlg {
diff --git a/cpp/test/prims/decoupled_lookback.cu b/cpp/test/prims/decoupled_lookback.cu
index c2dbd8ab4c..9409872f7c 100644
--- a/cpp/test/prims/decoupled_lookback.cu
+++ b/cpp/test/prims/decoupled_lookback.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <decoupled_lookback.cuh>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/device_utils.cu b/cpp/test/prims/device_utils.cu
index 1312d0a69e..fb76634659 100644
--- a/cpp/test/prims/device_utils.cu
+++ b/cpp/test/prims/device_utils.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <common/device_utils.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/dispersion.cu b/cpp/test/prims/dispersion.cu
index e3df65bd27..7e553daa13 100644
--- a/cpp/test/prims/dispersion.cu
+++ b/cpp/test/prims/dispersion.cu
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <cuda_utils.cuh>
 #include <metrics/dispersion.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <vector>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/dist_adj.cu b/cpp/test/prims/dist_adj.cu
index 9a26221f34..0c5b2df22e 100644
--- a/cpp/test/prims/dist_adj.cu
+++ b/cpp/test/prims/dist_adj.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <distance/distance.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/distance_base.cuh b/cpp/test/prims/distance_base.cuh
index 3615cf813b..c44ea91f70 100644
--- a/cpp/test/prims/distance_base.cuh
+++ b/cpp/test/prims/distance_base.cuh
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <distance/distance.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/divide.cu b/cpp/test/prims/divide.cu
deleted file mode 100644
index 6ac97d8125..0000000000
--- a/cpp/test/prims/divide.cu
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/divide.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-template <typename Type>
-__global__ void naiveDivideKernel(Type *out, const Type *in, Type scalar,
-                                  int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = in[idx] / scalar;
-  }
-}
-
-template <typename Type>
-void naiveDivide(Type *out, const Type *in, Type scalar, int len,
-                 cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveDivideKernel<Type><<<nblks, TPB, 0, stream>>>(out, in, scalar, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-class DivideTest
-  : public ::testing::TestWithParam<raft::linalg::UnaryOpInputs<T>> {
- protected:
-  void SetUp() override {
-    params =
-      ::testing::TestWithParam<raft::linalg::UnaryOpInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    raft::allocate(in, len);
-    raft::allocate(out_ref, len);
-    raft::allocate(out, len);
-    r.uniform(in, len, T(-1.0), T(1.0), stream);
-    naiveDivide(out_ref, in, params.scalar, len, stream);
-    divideScalar(out, in, params.scalar, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  UnaryOpInputs<T> params;
-  T *in, *out_ref, *out;
-};
-
-const std::vector<UnaryOpInputs<float>> inputsf = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-typedef DivideTest<float> DivideTestF;
-TEST_P(DivideTestF, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(DivideTests, DivideTestF, ::testing::ValuesIn(inputsf));
-
-typedef DivideTest<double> DivideTestD;
-const std::vector<UnaryOpInputs<double>> inputsd = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-TEST_P(DivideTestD, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(DivideTests, DivideTestD, ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/eig.cu b/cpp/test/prims/eig.cu
deleted file mode 100644
index e716f19446..0000000000
--- a/cpp/test/prims/eig.cu
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/eig.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct EigInputs {
-  T tolerance;
-  int len;
-  int n_row;
-  int n_col;
-  unsigned long long int seed;
-  int n;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const EigInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class EigTest : public ::testing::TestWithParam<EigInputs<T>> {
- protected:
-  void SetUp() override {
-    raft::handle_t handle;
-    stream = handle.get_stream();
-
-    params = ::testing::TestWithParam<EigInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-
-    raft::allocate(cov_matrix, len);
-    T cov_matrix_h[] = {1.0,  0.9, 0.81, 0.729, 0.9,   1.0,  0.9, 0.81,
-                        0.81, 0.9, 1.0,  0.9,   0.729, 0.81, 0.9, 1.0};
-    ASSERT(len == 16, "This test only works with 4x4 matrices!");
-    raft::update_device(cov_matrix, cov_matrix_h, len, stream);
-
-    raft::allocate(eig_vectors, len);
-    raft::allocate(eig_vals, params.n_col);
-    raft::allocate(eig_vectors_jacobi, len);
-    raft::allocate(eig_vals_jacobi, params.n_col);
-
-    T eig_vectors_ref_h[] = {0.2790, -0.6498, 0.6498, -0.2789, -0.5123, 0.4874,
-                             0.4874, -0.5123, 0.6498, 0.2789,  -0.2789, -0.6498,
-                             0.4874, 0.5123,  0.5123, 0.4874};
-    T eig_vals_ref_h[] = {0.0614, 0.1024, 0.3096, 3.5266};
-
-    raft::allocate(eig_vectors_ref, len);
-    raft::allocate(eig_vals_ref, params.n_col);
-
-    raft::update_device(eig_vectors_ref, eig_vectors_ref_h, len, stream);
-    raft::update_device(eig_vals_ref, eig_vals_ref_h, params.n_col, stream);
-
-    eigDC(handle, cov_matrix, params.n_row, params.n_col, eig_vectors, eig_vals,
-          stream);
-
-    T tol = 1.e-7;
-    int sweeps = 15;
-    eigJacobi(handle, cov_matrix, params.n_row, params.n_col,
-              eig_vectors_jacobi, eig_vals_jacobi, stream, tol, sweeps);
-
-    // test code for comparing two methods
-    len = params.n * params.n;
-    raft::allocate(cov_matrix_large, len);
-    raft::allocate(eig_vectors_large, len);
-    raft::allocate(eig_vectors_jacobi_large, len);
-    raft::allocate(eig_vals_large, params.n);
-    raft::allocate(eig_vals_jacobi_large, params.n);
-
-    r.uniform(cov_matrix_large, len, T(-1.0), T(1.0), stream);
-
-    eigDC(handle, cov_matrix_large, params.n, params.n, eig_vectors_large,
-          eig_vals_large, stream);
-    eigJacobi(handle, cov_matrix_large, params.n, params.n,
-              eig_vectors_jacobi_large, eig_vals_jacobi_large, stream, tol,
-              sweeps);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(cov_matrix));
-    CUDA_CHECK(cudaFree(eig_vectors));
-    CUDA_CHECK(cudaFree(eig_vectors_jacobi));
-    CUDA_CHECK(cudaFree(eig_vals));
-    CUDA_CHECK(cudaFree(eig_vals_jacobi));
-    CUDA_CHECK(cudaFree(eig_vectors_ref));
-    CUDA_CHECK(cudaFree(eig_vals_ref));
-  }
-
- protected:
-  EigInputs<T> params;
-  T *cov_matrix, *eig_vectors, *eig_vectors_jacobi, *eig_vectors_ref, *eig_vals,
-    *eig_vals_jacobi, *eig_vals_ref;
-
-  T *cov_matrix_large, *eig_vectors_large, *eig_vectors_jacobi_large,
-    *eig_vals_large, *eig_vals_jacobi_large;
-
-  cudaStream_t stream;
-};
-
-const std::vector<EigInputs<float>> inputsf2 = {
-  {0.001f, 4 * 4, 4, 4, 1234ULL, 256}};
-
-const std::vector<EigInputs<double>> inputsd2 = {
-  {0.001, 4 * 4, 4, 4, 1234ULL, 256}};
-
-typedef EigTest<float> EigTestValF;
-TEST_P(EigTestValF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals, params.n_col,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigTest<double> EigTestValD;
-TEST_P(EigTestValD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals, params.n_col,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef EigTest<float> EigTestVecF;
-TEST_P(EigTestVecF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors, params.len,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigTest<double> EigTestVecD;
-TEST_P(EigTestVecD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors, params.len,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef EigTest<float> EigTestValJacobiF;
-TEST_P(EigTestValJacobiF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals_jacobi, params.n_col,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigTest<double> EigTestValJacobiD;
-TEST_P(EigTestValJacobiD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals_jacobi, params.n_col,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef EigTest<float> EigTestVecJacobiF;
-TEST_P(EigTestVecJacobiF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors_jacobi, params.len,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigTest<double> EigTestVecJacobiD;
-TEST_P(EigTestVecJacobiD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors_jacobi, params.len,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef EigTest<float> EigTestVecCompareF;
-TEST_P(EigTestVecCompareF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(
-    eig_vectors_large, eig_vectors_jacobi_large, (params.n * params.n),
-    raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigTest<double> EigTestVecCompareD;
-TEST_P(EigTestVecCompareD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(
-    eig_vectors_large, eig_vectors_jacobi_large, (params.n * params.n),
-    raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestValF, ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestValD, ::testing::ValuesIn(inputsd2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestVecF, ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestVecD, ::testing::ValuesIn(inputsd2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestValJacobiF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestValJacobiD,
-                        ::testing::ValuesIn(inputsd2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestVecJacobiF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigTests, EigTestVecJacobiD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // namespace linalg
-}  // namespace raft
diff --git a/cpp/test/prims/eig_sel.cu b/cpp/test/prims/eig_sel.cu
deleted file mode 100644
index 85e5013311..0000000000
--- a/cpp/test/prims/eig_sel.cu
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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.
- */
-
-#if CUDART_VERSION >= 10010
-
-#include <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/eig.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct EigSelInputs {
-  T tolerance;
-  int len;
-  int n_row;
-  int n_col;
-  unsigned long long int seed;
-  int n;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const EigSelInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class EigSelTest : public ::testing::TestWithParam<EigSelInputs<T>> {
- protected:
-  void SetUp() override {
-    raft::handle_t handle;
-    stream = handle.get_stream();
-
-    params = ::testing::TestWithParam<EigSelInputs<T>>::GetParam();
-    int len = params.len;
-
-    raft::allocate(cov_matrix, len);
-    T cov_matrix_h[] = {1.0,  0.9, 0.81, 0.729, 0.9,   1.0,  0.9, 0.81,
-                        0.81, 0.9, 1.0,  0.9,   0.729, 0.81, 0.9, 1.0};
-    ASSERT(len == 16, "This test only works with 4x4 matrices!");
-    raft::update_device(cov_matrix, cov_matrix_h, len, stream);
-
-    raft::allocate(eig_vectors, 12);
-    raft::allocate(eig_vals, params.n_col);
-
-    T eig_vectors_ref_h[] = {-0.5123, 0.4874,  0.4874, -0.5123, 0.6498, 0.2789,
-                             -0.2789, -0.6498, 0.4874, 0.5123,  0.5123, 0.4874};
-    T eig_vals_ref_h[] = {0.1024, 0.3096, 3.5266, 3.5266};
-
-    raft::allocate(eig_vectors_ref, 12);
-    raft::allocate(eig_vals_ref, params.n_col);
-
-    raft::update_device(eig_vectors_ref, eig_vectors_ref_h, 12, stream);
-    raft::update_device(eig_vals_ref, eig_vals_ref_h, 4, stream);
-
-    eigSelDC(handle, cov_matrix, params.n_row, params.n_col, 3, eig_vectors,
-             eig_vals, EigVecMemUsage::OVERWRITE_INPUT, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(cov_matrix));
-    CUDA_CHECK(cudaFree(eig_vectors));
-    CUDA_CHECK(cudaFree(eig_vals));
-    CUDA_CHECK(cudaFree(eig_vectors_ref));
-    CUDA_CHECK(cudaFree(eig_vals_ref));
-  }
-
- protected:
-  EigSelInputs<T> params;
-  T *cov_matrix, *eig_vectors, *eig_vectors_ref, *eig_vals, *eig_vals_ref;
-
-  cudaStream_t stream;
-};
-
-const std::vector<EigSelInputs<float>> inputsf2 = {
-  {0.001f, 4 * 4, 4, 4, 1234ULL, 256}};
-
-const std::vector<EigSelInputs<double>> inputsd2 = {
-  {0.001, 4 * 4, 4, 4, 1234ULL, 256}};
-
-typedef EigSelTest<float> EigSelTestValF;
-TEST_P(EigSelTestValF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals, params.n_col,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigSelTest<double> EigSelTestValD;
-TEST_P(EigSelTestValD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vals_ref, eig_vals, params.n_col,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef EigSelTest<float> EigSelTestVecF;
-TEST_P(EigSelTestVecF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors, 12,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef EigSelTest<double> EigSelTestVecD;
-TEST_P(EigSelTestVecD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(eig_vectors_ref, eig_vectors, 12,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(EigSelTest, EigSelTestValF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigSelTest, EigSelTestValD,
-                        ::testing::ValuesIn(inputsd2));
-
-INSTANTIATE_TEST_CASE_P(EigSelTest, EigSelTestVecF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EigSelTest, EigSelTestVecD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // end namespace linalg
-}  // end namespace raft
-
-#endif
diff --git a/cpp/test/prims/eltwise.cu b/cpp/test/prims/eltwise.cu
deleted file mode 100644
index cbcc1d01ee..0000000000
--- a/cpp/test/prims/eltwise.cu
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/eltwise.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-//// Testing unary ops
-
-template <typename Type>
-__global__ void naiveScaleKernel(Type *out, const Type *in, Type scalar,
-                                 int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = scalar * in[idx];
-  }
-}
-
-template <typename Type>
-void naiveScale(Type *out, const Type *in, Type scalar, int len,
-                cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveScaleKernel<Type><<<nblks, TPB, 0, stream>>>(out, in, scalar, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-struct ScalarMultiplyInputs {
-  T tolerance;
-  int len;
-  T scalar;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os,
-                           const ScalarMultiplyInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class ScalarMultiplyTest
-  : public ::testing::TestWithParam<ScalarMultiplyInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<ScalarMultiplyInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    T scalar = params.scalar;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    allocate(in, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    r.uniform(in, len, T(-1.0), T(1.0), stream);
-    naiveScale(out_ref, in, scalar, len, stream);
-    scalarMultiply(out, in, scalar, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  ScalarMultiplyInputs<T> params;
-  T *in, *out_ref, *out;
-};
-
-const std::vector<ScalarMultiplyInputs<float>> inputsf1 = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-
-const std::vector<ScalarMultiplyInputs<double>> inputsd1 = {
-  {0.00000001, 1024 * 1024, 2.0, 1234ULL}};
-
-typedef ScalarMultiplyTest<float> ScalarMultiplyTestF;
-TEST_P(ScalarMultiplyTestF, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef ScalarMultiplyTest<double> ScalarMultiplyTestD;
-TEST_P(ScalarMultiplyTestD, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(ScalarMultiplyTests, ScalarMultiplyTestF,
-                        ::testing::ValuesIn(inputsf1));
-
-INSTANTIATE_TEST_CASE_P(ScalarMultiplyTests, ScalarMultiplyTestD,
-                        ::testing::ValuesIn(inputsd1));
-
-//// Testing binary ops
-
-template <typename Type>
-__global__ void naiveAddKernel(Type *out, const Type *in1, const Type *in2,
-                               int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = in1[idx] + in2[idx];
-  }
-}
-
-template <typename Type>
-void naiveAdd(Type *out, const Type *in1, const Type *in2, int len,
-              cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveAddKernel<Type><<<nblks, TPB, 0, stream>>>(out, in1, in2, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-struct EltwiseAddInputs {
-  T tolerance;
-  int len;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os,
-                           const EltwiseAddInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class EltwiseAddTest : public ::testing::TestWithParam<EltwiseAddInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<EltwiseAddInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    int len = params.len;
-    allocate(in1, len);
-    allocate(in2, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    r.uniform(in1, len, T(-1.0), T(1.0), stream);
-    r.uniform(in2, len, T(-1.0), T(1.0), stream);
-    naiveAdd(out_ref, in1, in2, len, stream);
-    eltwiseAdd(out, in1, in2, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in1));
-    CUDA_CHECK(cudaFree(in2));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  EltwiseAddInputs<T> params;
-  T *in1, *in2, *out_ref, *out;
-};
-
-const std::vector<EltwiseAddInputs<float>> inputsf2 = {
-  {0.000001f, 1024 * 1024, 1234ULL}};
-
-const std::vector<EltwiseAddInputs<double>> inputsd2 = {
-  {0.00000001, 1024 * 1024, 1234ULL}};
-
-typedef EltwiseAddTest<float> EltwiseAddTestF;
-TEST_P(EltwiseAddTestF, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef EltwiseAddTest<double> EltwiseAddTestD;
-TEST_P(EltwiseAddTestD, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(EltwiseAddTests, EltwiseAddTestF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(EltwiseAddTests, EltwiseAddTestD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/eltwise2d.cu b/cpp/test/prims/eltwise2d.cu
index f84f939230..1818bbb28b 100644
--- a/cpp/test/prims/eltwise2d.cu
+++ b/cpp/test/prims/eltwise2d.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <linalg/eltwise2d.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/entropy.cu b/cpp/test/prims/entropy.cu
index 0387f6bf87..e258695e9e 100644
--- a/cpp/test/prims/entropy.cu
+++ b/cpp/test/prims/entropy.cu
@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
 #include <metrics/entropy.cuh>
+#include <raft/cuda_utils.cuh>
 #include <random>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/epsilon_neighborhood.cu b/cpp/test/prims/epsilon_neighborhood.cu
index 39a847112b..930dec9445 100644
--- a/cpp/test/prims/epsilon_neighborhood.cu
+++ b/cpp/test/prims/epsilon_neighborhood.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
 #include <distance/epsilon_neighborhood.cuh>
 #include <random/make_blobs.cuh>
diff --git a/cpp/test/prims/fast_int_div.cu b/cpp/test/prims/fast_int_div.cu
index 9ab9648616..c70802ceb8 100644
--- a/cpp/test/prims/fast_int_div.cu
+++ b/cpp/test/prims/fast_int_div.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <common/fast_int_div.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/fused_l2_nn.cu b/cpp/test/prims/fused_l2_nn.cu
index 1c4a8c49d1..cd3cb59dc7 100644
--- a/cpp/test/prims/fused_l2_nn.cu
+++ b/cpp/test/prims/fused_l2_nn.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <distance/fused_l2_nn.cuh>
-#include <linalg/norm.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/norm.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/gather.cu b/cpp/test/prims/gather.cu
index 595246aced..dcda9a9a7c 100644
--- a/cpp/test/prims/gather.cu
+++ b/cpp/test/prims/gather.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <matrix/gather.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/gemm_layout.cu b/cpp/test/prims/gemm_layout.cu
deleted file mode 100644
index c352e5990f..0000000000
--- a/cpp/test/prims/gemm_layout.cu
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/gemm.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct GemmLayoutInputs {
-  int M;
-  int N;
-  int K;
-  bool zLayout;
-  bool xLayout;
-  bool yLayout;
-  unsigned long long int seed;
-};
-
-// Reference GEMM implementation.
-template <typename T>
-__global__ void naiveGemm(T *Z, T *X, T *Y, int M, int N, int K,
-                          bool isZColMajor, bool isXColMajor,
-                          bool isYColMajor) {
-  int tidx = blockIdx.x * blockDim.x + threadIdx.x;
-  int tidy = blockIdx.y * blockDim.y + threadIdx.y;
-
-  for (int m = tidy; m < M; m += (blockDim.y * gridDim.y)) {
-    for (int n = tidx; n < N; n += (blockDim.x * gridDim.x)) {
-      T temp = T(0.0);
-      for (int k = 0; k < K; k++) {
-        int xIndex = isXColMajor ? m + k * M : m * K + k;
-        int yIndex = isYColMajor ? k + n * K : k * N + n;
-        temp += X[xIndex] * Y[yIndex];
-      }
-      int zIndex = isZColMajor ? m + n * M : m * N + n;
-      Z[zIndex] = temp;
-    }
-  }
-}
-
-template <typename T>
-class GemmLayoutTest : public ::testing::TestWithParam<GemmLayoutInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<GemmLayoutInputs<T>>::GetParam();
-
-    raft::handle_t handle;
-    cudaStream_t stream = handle.get_stream();
-
-    raft::random::Rng r(params.seed);
-
-    // We compute Z = X * Y and compare against reference result
-    // Dimensions of X : M x K
-    // Dimensions of Y : K x N
-    // Dimensions of Z : M x N
-
-    T *X = NULL;  // Argument X
-    T *Y = NULL;  // Argument Y
-
-    size_t xElems = params.M * params.K;
-    size_t yElems = params.K * params.N;
-    size_t zElems = params.M * params.N;
-
-    CUDA_CHECK(cudaMalloc(&X, xElems * sizeof(T)));
-    CUDA_CHECK(cudaMalloc(&Y, yElems * sizeof(T)));
-    CUDA_CHECK(cudaMalloc(&refZ, zElems * sizeof(T)));
-    CUDA_CHECK(cudaMalloc(&Z, zElems * sizeof(T)));
-
-    r.uniform(X, xElems, T(-10.0), T(10.0), stream);
-    r.uniform(Y, yElems, T(-10.0), T(10.0), stream);
-
-    dim3 blocks(raft::ceildiv<int>(params.M, 128),
-                raft::ceildiv<int>(params.N, 4), 1);
-    dim3 threads(128, 4, 1);
-
-    naiveGemm<<<blocks, threads>>>(refZ, X, Y, params.M, params.N, params.K,
-                                   params.zLayout, params.xLayout,
-                                   params.yLayout);
-
-    gemm(handle, Z, X, Y, params.M, params.N, params.K, params.zLayout,
-         params.xLayout, params.yLayout, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(refZ));
-    CUDA_CHECK(cudaFree(Z));
-  }
-
- protected:
-  GemmLayoutInputs<T> params;
-  T *refZ = NULL;  // Reference result for comparison
-  T *Z = NULL;     // Computed result
-};
-
-const std::vector<GemmLayoutInputs<float>> inputsf = {
-  {80, 70, 80, true, true, true, 76433ULL},
-  {80, 100, 40, true, true, false, 426646ULL},
-  {20, 100, 20, true, false, true, 237703ULL},
-  {100, 60, 30, true, false, false, 538004ULL},
-  {50, 10, 60, false, true, true, 73012ULL},
-  {90, 90, 30, false, true, false, 538147ULL},
-  {30, 100, 10, false, false, true, 412352ULL},
-  {40, 80, 100, false, false, false, 297941ULL}};
-
-const std::vector<GemmLayoutInputs<double>> inputsd = {
-  {10, 70, 40, true, true, true, 535648ULL},
-  {30, 30, 30, true, true, false, 956681ULL},
-  {70, 80, 50, true, false, true, 875083ULL},
-  {80, 90, 70, true, false, false, 50744ULL},
-  {90, 90, 30, false, true, true, 506321ULL},
-  {40, 100, 70, false, true, false, 638418ULL},
-  {80, 50, 30, false, false, true, 701529ULL},
-  {50, 80, 60, false, false, false, 893038ULL}};
-
-typedef GemmLayoutTest<float> GemmLayoutTestF;
-TEST_P(GemmLayoutTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(refZ, Z, params.M * params.N,
-                                raft::CompareApprox<float>(1e-4)));
-}
-
-typedef GemmLayoutTest<double> GemmLayoutTestD;
-TEST_P(GemmLayoutTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(refZ, Z, params.M * params.N,
-                                raft::CompareApprox<float>(1e-6)));
-}
-
-INSTANTIATE_TEST_CASE_P(GemmLayoutTests, GemmLayoutTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(GemmLayoutTests, GemmLayoutTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/gram.cu b/cpp/test/prims/gram.cu
index 6c708e8d41..86d70161d4 100644
--- a/cpp/test/prims/gram.cu
+++ b/cpp/test/prims/gram.cu
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/matrix/kernelparams.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <common/host_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <iostream>
 #include <matrix/grammatrix.cuh>
 #include <matrix/kernelfactory.cuh>
 #include <memory>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/grid_sync.cu b/cpp/test/prims/grid_sync.cu
index 160f36dd99..20d70be40b 100644
--- a/cpp/test/prims/grid_sync.cu
+++ b/cpp/test/prims/grid_sync.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <common/grid_sync.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/hinge.cu b/cpp/test/prims/hinge.cu
index 15a0ade679..e6968e479a 100644
--- a/cpp/test/prims/hinge.cu
+++ b/cpp/test/prims/hinge.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <functions/hinge.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/histogram.cu b/cpp/test/prims/histogram.cu
index 1ae6ee5f35..e5e3aced41 100644
--- a/cpp/test/prims/histogram.cu
+++ b/cpp/test/prims/histogram.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <stats/histogram.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/homogeneityScore.cu b/cpp/test/prims/homogeneityScore.cu
index fdee3b82bb..efbb337a57 100644
--- a/cpp/test/prims/homogeneityScore.cu
+++ b/cpp/test/prims/homogeneityScore.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/jones_transform.cu b/cpp/test/prims/jones_transform.cu
index 9558a579ae..067847d65f 100644
--- a/cpp/test/prims/jones_transform.cu
+++ b/cpp/test/prims/jones_transform.cu
@@ -12,8 +12,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/klDivergence.cu b/cpp/test/prims/klDivergence.cu
index 5d7a0aa955..f14989077e 100644
--- a/cpp/test/prims/klDivergence.cu
+++ b/cpp/test/prims/klDivergence.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/knn.cu b/cpp/test/prims/knn.cu
index cb444d9980..5c02a80867 100644
--- a/cpp/test/prims/knn.cu
+++ b/cpp/test/prims/knn.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <iostream>
+#include <raft/cuda_utils.cuh>
 #include <selection/knn.cuh>
 #include <vector>
 #include "test_utils.h"
diff --git a/cpp/test/prims/knn_classify.cu b/cpp/test/prims/knn_classify.cu
index c395aaa132..f13a4ff38d 100644
--- a/cpp/test/prims/knn_classify.cu
+++ b/cpp/test/prims/knn_classify.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <iostream>
 #include <label/classlabels.cuh>
+#include <raft/cuda_utils.cuh>
 #include <random/make_blobs.cuh>
 #include <selection/knn.cuh>
 #include <vector>
diff --git a/cpp/test/prims/knn_regression.cu b/cpp/test/prims/knn_regression.cu
index fac9ae1482..844ddcb176 100644
--- a/cpp/test/prims/knn_regression.cu
+++ b/cpp/test/prims/knn_regression.cu
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cusolver_wrappers.h>
-#include <cuda_utils.cuh>
 #include <iostream>
 #include <label/classlabels.cuh>
-#include <linalg/reduce.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/reduce.cuh>
+#include <raft/random/rng.cuh>
 #include <selection/knn.cuh>
 #include <vector>
 #include "test_utils.h"
diff --git a/cpp/test/prims/kselection.cu b/cpp/test/prims/kselection.cu
index e9b4210bbc..2adf25f1bc 100644
--- a/cpp/test/prims/kselection.cu
+++ b/cpp/test/prims/kselection.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <limits>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include <selection/kselection.cuh>
 
 namespace MLCommon {
diff --git a/cpp/test/prims/label.cu b/cpp/test/prims/label.cu
index 39055886d7..b0e4d629da 100644
--- a/cpp/test/prims/label.cu
+++ b/cpp/test/prims/label.cu
@@ -18,9 +18,9 @@
 
 #include <label/classlabels.cuh>
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <cuml/common/cuml_allocator.hpp>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 #include <iostream>
diff --git a/cpp/test/prims/linearReg.cu b/cpp/test/prims/linearReg.cu
index 8a169a95fe..e91ea5a159 100644
--- a/cpp/test/prims/linearReg.cu
+++ b/cpp/test/prims/linearReg.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <functions/linearReg.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/log.cu b/cpp/test/prims/log.cu
index 206a6e74cb..c4397ac23a 100644
--- a/cpp/test/prims/log.cu
+++ b/cpp/test/prims/log.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <functions/log.cuh>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/logisticReg.cu b/cpp/test/prims/logisticReg.cu
index d9dfaf7281..b2eb3dc28f 100644
--- a/cpp/test/prims/logisticReg.cu
+++ b/cpp/test/prims/logisticReg.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <functions/logisticReg.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/make_arima.cu b/cpp/test/prims/make_arima.cu
index f753e18641..07f2120cf4 100644
--- a/cpp/test/prims/make_arima.cu
+++ b/cpp/test/prims/make_arima.cu
@@ -18,8 +18,8 @@
 #include <thrust/count.h>
 #include <thrust/device_vector.h>
 
-#include <common/cudart_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 #include <random/make_arima.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/make_blobs.cu b/cpp/test/prims/make_blobs.cu
index a5e5a2950c..81bf1627fc 100644
--- a/cpp/test/prims/make_blobs.cu
+++ b/cpp/test/prims/make_blobs.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include <random/make_blobs.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/make_regression.cu b/cpp/test/prims/make_regression.cu
index b1a27405fd..1f8305fdd6 100644
--- a/cpp/test/prims/make_regression.cu
+++ b/cpp/test/prims/make_regression.cu
@@ -18,11 +18,11 @@
 #include <thrust/count.h>
 #include <thrust/device_vector.h>
 
-#include <common/cudart_utils.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
-#include <cuda_utils.cuh>
-#include <linalg/subtract.cuh>
+#include <raft/linalg/transpose.h>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/subtract.cuh>
 #include <random/make_regression.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/map_then_reduce.cu b/cpp/test/prims/map_then_reduce.cu
deleted file mode 100644
index 00e1feb668..0000000000
--- a/cpp/test/prims/map_then_reduce.cu
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/map_then_reduce.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename Type, typename MapOp>
-__global__ void naiveMapReduceKernel(Type *out, const Type *in, size_t len,
-                                     MapOp map) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    raft::myAtomicAdd(out, map(in[idx]));
-  }
-}
-
-template <typename Type, typename MapOp>
-void naiveMapReduce(Type *out, const Type *in, size_t len, MapOp map,
-                    cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, (size_t)TPB);
-  naiveMapReduceKernel<Type, MapOp>
-    <<<nblks, TPB, 0, stream>>>(out, in, len, map);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-struct MapReduceInputs {
-  T tolerance;
-  size_t len;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const MapReduceInputs<T> &dims) {
-  return os;
-}
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename T>
-void mapReduceLaunch(T *out_ref, T *out, const T *in, size_t len,
-                     cudaStream_t stream) {
-  auto op = [] __device__(T in) { return in; };
-  naiveMapReduce(out_ref, in, len, op, stream);
-  mapThenSumReduce(out, len, op, 0, in);
-}
-
-template <typename T>
-class MapReduceTest : public ::testing::TestWithParam<MapReduceInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MapReduceInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    auto len = params.len;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    allocate(in, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    r.uniform(in, len, T(-1.0), T(1.0), stream);
-    mapReduceLaunch(out_ref, out, in, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  MapReduceInputs<T> params;
-  T *in, *out_ref, *out;
-};
-
-const std::vector<MapReduceInputs<float>> inputsf = {
-  {0.001f, 1024 * 1024, 1234ULL}};
-typedef MapReduceTest<float> MapReduceTestF;
-TEST_P(MapReduceTestF, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MapReduceTests, MapReduceTestF,
-                        ::testing::ValuesIn(inputsf));
-
-const std::vector<MapReduceInputs<double>> inputsd = {
-  {0.000001, 1024 * 1024, 1234ULL}};
-typedef MapReduceTest<double> MapReduceTestD;
-TEST_P(MapReduceTestD, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MapReduceTests, MapReduceTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/math.cu b/cpp/test/prims/math.cu
deleted file mode 100644
index 0c9c77ee52..0000000000
--- a/cpp/test/prims/math.cu
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <matrix/math.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace matrix {
-
-template <typename Type>
-__global__ void nativePowerKernel(Type *in, Type *out, int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = in[idx] * in[idx];
-  }
-}
-
-template <typename Type>
-void naivePower(Type *in, Type *out, int len, cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  nativePowerKernel<Type><<<nblks, TPB, 0, stream>>>(in, out, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type>
-__global__ void nativeSqrtKernel(Type *in, Type *out, int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = sqrt(in[idx]);
-  }
-}
-
-template <typename Type>
-void naiveSqrt(Type *in, Type *out, int len) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  nativeSqrtKernel<Type><<<nblks, TPB>>>(in, out, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type>
-__global__ void naiveSignFlipKernel(Type *in, Type *out, int rowCount,
-                                    int colCount) {
-  int d_i = blockIdx.x * rowCount;
-  int end = d_i + rowCount;
-
-  if (blockIdx.x < colCount) {
-    Type max = 0.0;
-    int max_index = 0;
-    for (int i = d_i; i < end; i++) {
-      Type val = in[i];
-      if (val < 0.0) {
-        val = -val;
-      }
-      if (val > max) {
-        max = val;
-        max_index = i;
-      }
-    }
-
-    for (int i = d_i; i < end; i++) {
-      if (in[max_index] < 0.0) {
-        out[i] = -in[i];
-      } else {
-        out[i] = in[i];
-      }
-    }
-  }
-
-  __syncthreads();
-}
-
-template <typename Type>
-void naiveSignFlip(Type *in, Type *out, int rowCount, int colCount) {
-  naiveSignFlipKernel<Type><<<colCount, 1>>>(in, out, rowCount, colCount);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-struct MathInputs {
-  T tolerance;
-  int n_row;
-  int n_col;
-  int len;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const MathInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class MathTest : public ::testing::TestWithParam<MathInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MathInputs<T>>::GetParam();
-    random::Rng r(params.seed);
-    int len = params.len;
-
-    allocate(in_power, len);
-    allocate(out_power_ref, len);
-    allocate(in_sqrt, len);
-    allocate(out_sqrt_ref, len);
-    allocate(in_sign_flip, len);
-    allocate(out_sign_flip_ref, len);
-
-    raft::handle_t handle;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    allocate(in_ratio, 4);
-    T in_ratio_h[4] = {1.0, 2.0, 2.0, 3.0};
-    update_device(in_ratio, in_ratio_h, 4, stream);
-
-    allocate(out_ratio_ref, 4);
-    T out_ratio_ref_h[4] = {0.125, 0.25, 0.25, 0.375};
-    update_device(out_ratio_ref, out_ratio_ref_h, 4, stream);
-
-    r.uniform(in_power, len, T(-1.0), T(1.0), stream);
-    r.uniform(in_sqrt, len, T(0.0), T(1.0), stream);
-    // r.uniform(in_ratio, len, T(0.0), T(1.0));
-    r.uniform(in_sign_flip, len, T(-100.0), T(100.0), stream);
-
-    naivePower(in_power, out_power_ref, len, stream);
-    power(in_power, len, stream);
-
-    naiveSqrt(in_sqrt, out_sqrt_ref, len);
-    seqRoot(in_sqrt, len, stream);
-
-    ratio(handle, in_ratio, in_ratio, 4, stream);
-
-    naiveSignFlip(in_sign_flip, out_sign_flip_ref, params.n_row, params.n_col);
-    signFlip(in_sign_flip, params.n_row, params.n_col, stream);
-
-    allocate(in_recip, 4);
-    allocate(in_recip_ref, 4);
-    allocate(out_recip, 4);
-    // default threshold is 1e-15
-    std::vector<T> in_recip_h = {0.1, 0.01, -0.01, 0.1e-16};
-    std::vector<T> in_recip_ref_h = {10.0, 100.0, -100.0, 0.0};
-    update_device(in_recip, in_recip_h.data(), 4, stream);
-    update_device(in_recip_ref, in_recip_ref_h.data(), 4, stream);
-    T recip_scalar = T(1.0);
-
-    // this `reciprocal()` has to go first bc next one modifies its input
-    reciprocal(in_recip, out_recip, recip_scalar, 4, stream);
-
-    reciprocal(in_recip, recip_scalar, 4, stream, true);
-
-    std::vector<T> in_small_val_zero_h = {0.1, 1e-16, -1e-16, -0.1};
-    std::vector<T> in_small_val_zero_ref_h = {0.1, 0.0, 0.0, -0.1};
-    allocate(in_smallzero, 4);
-    allocate(out_smallzero, 4);
-    allocate(out_smallzero_ref, 4);
-    update_device(in_smallzero, in_small_val_zero_h.data(), 4, stream);
-    update_device(out_smallzero_ref, in_small_val_zero_ref_h.data(), 4, stream);
-    setSmallValuesZero(out_smallzero, in_smallzero, 4, stream);
-    setSmallValuesZero(in_smallzero, 4, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in_power));
-    CUDA_CHECK(cudaFree(out_power_ref));
-    CUDA_CHECK(cudaFree(in_sqrt));
-    CUDA_CHECK(cudaFree(out_sqrt_ref));
-    CUDA_CHECK(cudaFree(in_ratio));
-    CUDA_CHECK(cudaFree(out_ratio_ref));
-    CUDA_CHECK(cudaFree(in_sign_flip));
-    CUDA_CHECK(cudaFree(out_sign_flip_ref));
-    CUDA_CHECK(cudaFree(in_recip));
-    CUDA_CHECK(cudaFree(in_recip_ref));
-    CUDA_CHECK(cudaFree(out_recip));
-    CUDA_CHECK(cudaFree(in_smallzero));
-    CUDA_CHECK(cudaFree(out_smallzero));
-    CUDA_CHECK(cudaFree(out_smallzero_ref));
-  }
-
- protected:
-  MathInputs<T> params;
-  T *in_power, *out_power_ref, *in_sqrt, *out_sqrt_ref, *in_ratio,
-    *out_ratio_ref, *in_sign_flip, *out_sign_flip_ref, *in_recip, *in_recip_ref,
-    *out_recip, *in_smallzero, *out_smallzero, *out_smallzero_ref;
-};
-
-const std::vector<MathInputs<float>> inputsf = {
-  {0.00001f, 1024, 1024, 1024 * 1024, 1234ULL}};
-
-const std::vector<MathInputs<double>> inputsd = {
-  {0.00001, 1024, 1024, 1024 * 1024, 1234ULL}};
-
-typedef MathTest<float> MathPowerTestF;
-TEST_P(MathPowerTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_power, out_power_ref, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathPowerTestD;
-TEST_P(MathPowerTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_power, out_power_ref, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-typedef MathTest<float> MathSqrtTestF;
-TEST_P(MathSqrtTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_sqrt, out_sqrt_ref, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathSqrtTestD;
-TEST_P(MathSqrtTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_sqrt, out_sqrt_ref, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-typedef MathTest<float> MathRatioTestF;
-TEST_P(MathRatioTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_ratio, out_ratio_ref, 4,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathRatioTestD;
-TEST_P(MathRatioTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_ratio, out_ratio_ref, 4,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-typedef MathTest<float> MathSignFlipTestF;
-TEST_P(MathSignFlipTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_sign_flip, out_sign_flip_ref, params.len,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathSignFlipTestD;
-TEST_P(MathSignFlipTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_sign_flip, out_sign_flip_ref, params.len,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-typedef MathTest<float> MathReciprocalTestF;
-TEST_P(MathReciprocalTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_recip, in_recip_ref, 4,
-                          CompareApprox<float>(params.tolerance)));
-
-  // 4-th term tests `setzero=true` functionality, not present in this version of `reciprocal`.
-  ASSERT_TRUE(devArrMatch(out_recip, in_recip_ref, 3,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathReciprocalTestD;
-TEST_P(MathReciprocalTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_recip, in_recip_ref, 4,
-                          CompareApprox<double>(params.tolerance)));
-
-  // 4-th term tests `setzero=true` functionality, not present in this version of `reciprocal`.
-  ASSERT_TRUE(devArrMatch(out_recip, in_recip_ref, 3,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-typedef MathTest<float> MathSetSmallZeroTestF;
-TEST_P(MathSetSmallZeroTestF, Result) {
-  ASSERT_TRUE(devArrMatch(in_smallzero, out_smallzero_ref, 4,
-                          CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(devArrMatch(out_smallzero, out_smallzero_ref, 4,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MathTest<double> MathSetSmallZeroTestD;
-TEST_P(MathSetSmallZeroTestD, Result) {
-  ASSERT_TRUE(devArrMatch(in_smallzero, out_smallzero_ref, 4,
-                          CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(devArrMatch(out_smallzero, out_smallzero_ref, 4,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathPowerTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathPowerTestD,
-                        ::testing::ValuesIn(inputsd));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathSqrtTestF, ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathSqrtTestD, ::testing::ValuesIn(inputsd));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathRatioTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathRatioTestD,
-                        ::testing::ValuesIn(inputsd));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathSignFlipTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathSignFlipTestD,
-                        ::testing::ValuesIn(inputsd));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathReciprocalTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathReciprocalTestD,
-                        ::testing::ValuesIn(inputsd));
-
-INSTANTIATE_TEST_CASE_P(MathTests, MathSetSmallZeroTestF,
-                        ::testing::ValuesIn(inputsf));
-INSTANTIATE_TEST_CASE_P(MathTests, MathSetSmallZeroTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // namespace matrix
-}  // namespace raft
diff --git a/cpp/test/prims/matrix.cu b/cpp/test/prims/matrix.cu
deleted file mode 100644
index 5283488009..0000000000
--- a/cpp/test/prims/matrix.cu
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <matrix/matrix.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace matrix {
-
-template <typename T>
-struct MatrixInputs {
-  T tolerance;
-  int n_row;
-  int n_col;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const MatrixInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class MatrixTest : public ::testing::TestWithParam<MatrixInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MatrixInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.n_row * params.n_col;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(in1, len);
-    raft::allocate(in2, len);
-    raft::allocate(in1_revr, len);
-    r.uniform(in1, len, T(-1.0), T(1.0), stream);
-
-    copy(in1, in2, params.n_row, params.n_col, stream);
-    // copy(in1, in1_revr, params.n_row, params.n_col);
-    // colReverse(in1_revr, params.n_row, params.n_col);
-
-    T *outTrunc;
-    raft::allocate(outTrunc, 6);
-    truncZeroOrigin(in1, params.n_row, outTrunc, 3, 2, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in1));
-    CUDA_CHECK(cudaFree(in2));
-    // CUDA_CHECK(cudaFree(in1_revr));
-  }
-
- protected:
-  MatrixInputs<T> params;
-  T *in1, *in2, *in1_revr;
-};
-
-const std::vector<MatrixInputs<float>> inputsf2 = {{0.000001f, 4, 4, 1234ULL}};
-
-const std::vector<MatrixInputs<double>> inputsd2 = {
-  {0.00000001, 4, 4, 1234ULL}};
-
-typedef MatrixTest<float> MatrixTestF;
-TEST_P(MatrixTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(in1, in2, params.n_row * params.n_col,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef MatrixTest<double> MatrixTestD;
-TEST_P(MatrixTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(in1, in2, params.n_row * params.n_col,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(MatrixTests, MatrixTestF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(MatrixTests, MatrixTestD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // namespace matrix
-}  // namespace raft
diff --git a/cpp/test/prims/matrix_vector_op.cu b/cpp/test/prims/matrix_vector_op.cu
deleted file mode 100644
index 3663cb9350..0000000000
--- a/cpp/test/prims/matrix_vector_op.cu
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <random/rng.cuh>
-#include "matrix_vector_op.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T, typename IdxType = int>
-struct MatVecOpInputs {
-  T tolerance;
-  IdxType rows, cols;
-  bool rowMajor, bcastAlongRows, useTwoVectors;
-  unsigned long long int seed;
-};
-
-template <typename T, typename IdxType>
-::std::ostream &operator<<(::std::ostream &os,
-                           const MatVecOpInputs<T, IdxType> &dims) {
-  return os;
-}
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename T, typename IdxType>
-void matrixVectorOpLaunch(T *out, const T *in, const T *vec1, const T *vec2,
-                          IdxType D, IdxType N, bool rowMajor,
-                          bool bcastAlongRows, bool useTwoVectors,
-                          cudaStream_t stream) {
-  if (useTwoVectors) {
-    matrixVectorOp(
-      out, in, vec1, vec2, D, N, rowMajor, bcastAlongRows,
-      [] __device__(T a, T b, T c) { return a + b + c; }, stream);
-  } else {
-    matrixVectorOp(
-      out, in, vec1, D, N, rowMajor, bcastAlongRows,
-      [] __device__(T a, T b) { return a + b; }, stream);
-  }
-}
-
-template <typename T, typename IdxType>
-class MatVecOpTest
-  : public ::testing::TestWithParam<MatVecOpInputs<T, IdxType>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MatVecOpInputs<T, IdxType>>::GetParam();
-    raft::random::Rng r(params.seed);
-    IdxType N = params.rows, D = params.cols;
-    IdxType len = N * D;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    allocate(in, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    IdxType vecLen = params.bcastAlongRows ? D : N;
-    allocate(vec1, vecLen);
-    allocate(vec2, vecLen);
-    r.uniform(in, len, (T)-1.0, (T)1.0, stream);
-    r.uniform(vec1, vecLen, (T)-1.0, (T)1.0, stream);
-    r.uniform(vec2, vecLen, (T)-1.0, (T)1.0, stream);
-    if (params.useTwoVectors) {
-      naiveMatVec(out_ref, in, vec1, vec2, D, N, params.rowMajor,
-                  params.bcastAlongRows, (T)1.0);
-    } else {
-      naiveMatVec(out_ref, in, vec1, D, N, params.rowMajor,
-                  params.bcastAlongRows, (T)1.0);
-    }
-    matrixVectorOpLaunch(out, in, vec1, vec2, D, N, params.rowMajor,
-                         params.bcastAlongRows, params.useTwoVectors, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(vec1));
-    CUDA_CHECK(cudaFree(vec2));
-    CUDA_CHECK(cudaFree(out));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(in));
-  }
-
- protected:
-  MatVecOpInputs<T, IdxType> params;
-  T *in, *out, *out_ref, *vec1, *vec2;
-};
-
-const std::vector<MatVecOpInputs<float, int>> inputsf_i32 = {
-  {0.00001f, 1024, 32, true, true, false, 1234ULL},
-  {0.00001f, 1024, 64, true, true, false, 1234ULL},
-  {0.00001f, 1024, 32, true, false, false, 1234ULL},
-  {0.00001f, 1024, 64, true, false, false, 1234ULL},
-  {0.00001f, 1024, 32, false, true, false, 1234ULL},
-  {0.00001f, 1024, 64, false, true, false, 1234ULL},
-  {0.00001f, 1024, 32, false, false, false, 1234ULL},
-  {0.00001f, 1024, 64, false, false, false, 1234ULL},
-
-  {0.00001f, 1024, 32, true, true, true, 1234ULL},
-  {0.00001f, 1024, 64, true, true, true, 1234ULL},
-  {0.00001f, 1024, 32, true, false, true, 1234ULL},
-  {0.00001f, 1024, 64, true, false, true, 1234ULL},
-  {0.00001f, 1024, 32, false, true, true, 1234ULL},
-  {0.00001f, 1024, 64, false, true, true, 1234ULL},
-  {0.00001f, 1024, 32, false, false, true, 1234ULL},
-  {0.00001f, 1024, 64, false, false, true, 1234ULL}};
-typedef MatVecOpTest<float, int> MatVecOpTestF_i32;
-TEST_P(MatVecOpTestF_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.rows * params.cols,
-                          CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MatVecOpTests, MatVecOpTestF_i32,
-                        ::testing::ValuesIn(inputsf_i32));
-
-const std::vector<MatVecOpInputs<float, size_t>> inputsf_i64 = {
-  {0.00001f, 2500, 250, false, false, false, 1234ULL},
-  {0.00001f, 2500, 250, false, false, true, 1234ULL}};
-typedef MatVecOpTest<float, size_t> MatVecOpTestF_i64;
-TEST_P(MatVecOpTestF_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.rows * params.cols,
-                          CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MatVecOpTests, MatVecOpTestF_i64,
-                        ::testing::ValuesIn(inputsf_i64));
-
-const std::vector<MatVecOpInputs<double, int>> inputsd_i32 = {
-  {0.0000001, 1024, 32, true, true, false, 1234ULL},
-  {0.0000001, 1024, 64, true, true, false, 1234ULL},
-  {0.0000001, 1024, 32, true, false, false, 1234ULL},
-  {0.0000001, 1024, 64, true, false, false, 1234ULL},
-  {0.0000001, 1024, 32, false, true, false, 1234ULL},
-  {0.0000001, 1024, 64, false, true, false, 1234ULL},
-  {0.0000001, 1024, 32, false, false, false, 1234ULL},
-  {0.0000001, 1024, 64, false, false, false, 1234ULL},
-
-  {0.0000001, 1024, 32, true, true, true, 1234ULL},
-  {0.0000001, 1024, 64, true, true, true, 1234ULL},
-  {0.0000001, 1024, 32, true, false, true, 1234ULL},
-  {0.0000001, 1024, 64, true, false, true, 1234ULL},
-  {0.0000001, 1024, 32, false, true, true, 1234ULL},
-  {0.0000001, 1024, 64, false, true, true, 1234ULL},
-  {0.0000001, 1024, 32, false, false, true, 1234ULL},
-  {0.0000001, 1024, 64, false, false, true, 1234ULL}};
-typedef MatVecOpTest<double, int> MatVecOpTestD_i32;
-TEST_P(MatVecOpTestD_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.rows * params.cols,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MatVecOpTests, MatVecOpTestD_i32,
-                        ::testing::ValuesIn(inputsd_i32));
-
-const std::vector<MatVecOpInputs<double, size_t>> inputsd_i64 = {
-  {0.0000001, 2500, 250, false, false, false, 1234ULL},
-  {0.0000001, 2500, 250, false, false, true, 1234ULL}};
-typedef MatVecOpTest<double, size_t> MatVecOpTestD_i64;
-TEST_P(MatVecOpTestD_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.rows * params.cols,
-                          CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MatVecOpTests, MatVecOpTestD_i64,
-                        ::testing::ValuesIn(inputsd_i64));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/matrix_vector_op.cuh b/cpp/test/prims/matrix_vector_op.cuh
deleted file mode 100644
index c8eaf2f0d8..0000000000
--- a/cpp/test/prims/matrix_vector_op.cuh
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <linalg/matrix_vector_op.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename Type, typename IdxType = int>
-__global__ void naiveMatVecKernel(Type *out, const Type *mat, const Type *vec,
-                                  IdxType D, IdxType N, bool rowMajor,
-                                  bool bcastAlongRows, Type scalar) {
-  IdxType idx = threadIdx.x + blockIdx.x * blockDim.x;
-  IdxType len = N * D;
-  IdxType col;
-  if (rowMajor && bcastAlongRows) {
-    col = idx % D;
-  } else if (!rowMajor && !bcastAlongRows) {
-    col = idx % N;
-  } else if (rowMajor && !bcastAlongRows) {
-    col = idx / D;
-  } else {
-    col = idx / N;
-  }
-  if (idx < len) {
-    out[idx] = mat[idx] + scalar * vec[col];
-  }
-}
-
-template <typename Type, typename IdxType = int>
-void naiveMatVec(Type *out, const Type *mat, const Type *vec, IdxType D,
-                 IdxType N, bool rowMajor, bool bcastAlongRows, Type scalar) {
-  static const IdxType TPB = 64;
-  IdxType len = N * D;
-  IdxType nblks = raft::ceildiv(len, TPB);
-  naiveMatVecKernel<Type>
-    <<<nblks, TPB>>>(out, mat, vec, D, N, rowMajor, bcastAlongRows, scalar);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type, typename IdxType = int>
-__global__ void naiveMatVecKernel(Type *out, const Type *mat, const Type *vec1,
-                                  const Type *vec2, IdxType D, IdxType N,
-                                  bool rowMajor, bool bcastAlongRows,
-                                  Type scalar) {
-  IdxType idx = threadIdx.x + blockIdx.x * blockDim.x;
-  IdxType len = N * D;
-  IdxType col;
-  if (rowMajor && bcastAlongRows) {
-    col = idx % D;
-  } else if (!rowMajor && !bcastAlongRows) {
-    col = idx % N;
-  } else if (rowMajor && !bcastAlongRows) {
-    col = idx / D;
-  } else {
-    col = idx / N;
-  }
-  if (idx < len) {
-    out[idx] = mat[idx] + scalar * vec1[col] + vec2[col];
-  }
-}
-
-template <typename Type, typename IdxType = int>
-void naiveMatVec(Type *out, const Type *mat, const Type *vec1, const Type *vec2,
-                 IdxType D, IdxType N, bool rowMajor, bool bcastAlongRows,
-                 Type scalar) {
-  static const IdxType TPB = 64;
-  IdxType len = N * D;
-  IdxType nblks = raft::ceildiv(len, TPB);
-  naiveMatVecKernel<Type><<<nblks, TPB>>>(out, mat, vec1, vec2, D, N, rowMajor,
-                                          bcastAlongRows, scalar);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/mean.cu b/cpp/test/prims/mean.cu
deleted file mode 100644
index dcb41628ee..0000000000
--- a/cpp/test/prims/mean.cu
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include <stats/mean.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace stats {
-
-template <typename T>
-struct MeanInputs {
-  T tolerance, mean;
-  int rows, cols;
-  bool sample, rowMajor;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const MeanInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class MeanTest : public ::testing::TestWithParam<MeanInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MeanInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    allocate(data, len);
-    allocate(mean_act, cols);
-    r.normal(data, len, params.mean, (T)1.0, stream);
-
-    meanSGtest(data, stream);
-  }
-
-  void meanSGtest(T *data, cudaStream_t stream) {
-    int rows = params.rows, cols = params.cols;
-
-    mean(mean_act, data, cols, rows, params.sample, params.rowMajor, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(mean_act));
-  }
-
- protected:
-  MeanInputs<T> params;
-  T *data, *mean_act;
-};
-
-// Note: For 1024 samples, 256 experiments, a mean of 1.0 with stddev=1.0, the
-// measured mean (of a normal distribution) will fall outside of an epsilon of
-// 0.15 only 4/10000 times. (epsilon of 0.1 will fail 30/100 times)
-const std::vector<MeanInputs<float>> inputsf = {
-  {0.15f, 1.f, 1024, 32, true, false, 1234ULL},
-  {0.15f, 1.f, 1024, 64, true, false, 1234ULL},
-  {0.15f, 1.f, 1024, 128, true, false, 1234ULL},
-  {0.15f, 1.f, 1024, 256, true, false, 1234ULL},
-  {0.15f, -1.f, 1024, 32, false, false, 1234ULL},
-  {0.15f, -1.f, 1024, 64, false, false, 1234ULL},
-  {0.15f, -1.f, 1024, 128, false, false, 1234ULL},
-  {0.15f, -1.f, 1024, 256, false, false, 1234ULL},
-  {0.15f, 1.f, 1024, 32, true, true, 1234ULL},
-  {0.15f, 1.f, 1024, 64, true, true, 1234ULL},
-  {0.15f, 1.f, 1024, 128, true, true, 1234ULL},
-  {0.15f, 1.f, 1024, 256, true, true, 1234ULL},
-  {0.15f, -1.f, 1024, 32, false, true, 1234ULL},
-  {0.15f, -1.f, 1024, 64, false, true, 1234ULL},
-  {0.15f, -1.f, 1024, 128, false, true, 1234ULL},
-  {0.15f, -1.f, 1024, 256, false, true, 1234ULL}};
-
-const std::vector<MeanInputs<double>> inputsd = {
-  {0.15, 1.0, 1024, 32, true, false, 1234ULL},
-  {0.15, 1.0, 1024, 64, true, false, 1234ULL},
-  {0.15, 1.0, 1024, 128, true, false, 1234ULL},
-  {0.15, 1.0, 1024, 256, true, false, 1234ULL},
-  {0.15, -1.0, 1024, 32, false, false, 1234ULL},
-  {0.15, -1.0, 1024, 64, false, false, 1234ULL},
-  {0.15, -1.0, 1024, 128, false, false, 1234ULL},
-  {0.15, -1.0, 1024, 256, false, false, 1234ULL},
-  {0.15, 1.0, 1024, 32, true, true, 1234ULL},
-  {0.15, 1.0, 1024, 64, true, true, 1234ULL},
-  {0.15, 1.0, 1024, 128, true, true, 1234ULL},
-  {0.15, 1.0, 1024, 256, true, true, 1234ULL},
-  {0.15, -1.0, 1024, 32, false, true, 1234ULL},
-  {0.15, -1.0, 1024, 64, false, true, 1234ULL},
-  {0.15, -1.0, 1024, 128, false, true, 1234ULL},
-  {0.15, -1.0, 1024, 256, false, true, 1234ULL}};
-
-typedef MeanTest<float> MeanTestF;
-TEST_P(MeanTestF, Result) {
-  ASSERT_TRUE(devArrMatch(params.mean, mean_act, params.cols,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef MeanTest<double> MeanTestD;
-TEST_P(MeanTestD, Result) {
-  ASSERT_TRUE(devArrMatch(params.mean, mean_act, params.cols,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(MeanTests, MeanTestF, ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(MeanTests, MeanTestD, ::testing::ValuesIn(inputsd));
-
-}  // end namespace stats
-}  // end namespace raft
diff --git a/cpp/test/prims/mean_center.cu b/cpp/test/prims/mean_center.cu
deleted file mode 100644
index 1809865fdd..0000000000
--- a/cpp/test/prims/mean_center.cu
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <random/rng.cuh>
-#include <stats/mean.cuh>
-#include <stats/mean_center.cuh>
-#include "matrix_vector_op.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace stats {
-
-template <typename T, typename IdxType>
-struct MeanCenterInputs {
-  T tolerance, mean;
-  IdxType rows, cols;
-  bool sample, rowMajor, bcastAlongRows;
-  unsigned long long int seed;
-};
-
-template <typename T, typename IdxType>
-::std::ostream &operator<<(::std::ostream &os,
-                           const MeanCenterInputs<T, IdxType> &dims) {
-  return os;
-}
-
-template <typename T, typename IdxType>
-class MeanCenterTest
-  : public ::testing::TestWithParam<MeanCenterInputs<T, IdxType>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<MeanCenterInputs<T, IdxType>>::GetParam();
-    raft::random::Rng r(params.seed);
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    auto rows = params.rows, cols = params.cols;
-    auto len = rows * cols;
-    IdxType vecLen = params.bcastAlongRows ? cols : rows;
-
-    raft::allocate(out, len);
-    raft::allocate(out_ref, len);
-    raft::allocate(data, len);
-    raft::allocate(meanVec, vecLen);
-    r.normal(data, len, params.mean, (T)1.0, stream);
-    raft::stats::mean(meanVec, data, cols, rows, params.sample, params.rowMajor,
-                      stream);
-    meanCenter(out, data, meanVec, cols, rows, params.rowMajor,
-               params.bcastAlongRows, stream);
-    raft::linalg::naiveMatVec(out_ref, data, meanVec, cols, rows,
-                              params.rowMajor, params.bcastAlongRows, (T)-1.0);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(out));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(meanVec));
-  }
-
- protected:
-  MeanCenterInputs<T, IdxType> params;
-  T *data, *meanVec, *out, *out_ref;
-};
-
-const std::vector<MeanCenterInputs<float, int>> inputsf_i32 = {
-  {0.05f, 1.f, 1024, 32, true, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, true, false, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, true, false, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, true, false, 1234ULL}};
-typedef MeanCenterTest<float, int> MeanCenterTestF_i32;
-TEST_P(MeanCenterTestF_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out, out_ref, params.cols,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MeanCenterTests, MeanCenterTestF_i32,
-                        ::testing::ValuesIn(inputsf_i32));
-
-const std::vector<MeanCenterInputs<float, size_t>> inputsf_i64 = {
-  {0.05f, 1.f, 1024, 32, true, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, false, true, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, false, true, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, true, true, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, true, true, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, false, false, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, false, false, 1234ULL},
-  {0.05f, 1.f, 1024, 32, true, true, false, 1234ULL},
-  {0.05f, 1.f, 1024, 64, true, true, false, 1234ULL},
-  {0.05f, 1.f, 1024, 128, true, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 32, false, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 64, false, true, false, 1234ULL},
-  {0.05f, -1.f, 1024, 128, false, true, false, 1234ULL}};
-typedef MeanCenterTest<float, size_t> MeanCenterTestF_i64;
-TEST_P(MeanCenterTestF_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out, out_ref, params.cols,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MeanCenterTests, MeanCenterTestF_i64,
-                        ::testing::ValuesIn(inputsf_i64));
-
-const std::vector<MeanCenterInputs<double, int>> inputsd_i32 = {
-  {0.05, 1.0, 1024, 32, true, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, true, false, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, true, false, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, true, false, 1234ULL}};
-typedef MeanCenterTest<double, int> MeanCenterTestD_i32;
-TEST_P(MeanCenterTestD_i32, Result) {
-  ASSERT_TRUE(devArrMatch(out, out_ref, params.cols,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MeanCenterTests, MeanCenterTestD_i32,
-                        ::testing::ValuesIn(inputsd_i32));
-
-const std::vector<MeanCenterInputs<double, size_t>> inputsd_i64 = {
-  {0.05, 1.0, 1024, 32, true, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, false, true, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, false, true, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, true, true, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, true, true, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, false, false, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, false, false, 1234ULL},
-  {0.05, 1.0, 1024, 32, true, true, false, 1234ULL},
-  {0.05, 1.0, 1024, 64, true, true, false, 1234ULL},
-  {0.05, 1.0, 1024, 128, true, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 32, false, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 64, false, true, false, 1234ULL},
-  {0.05, -1.0, 1024, 128, false, true, false, 1234ULL}};
-typedef MeanCenterTest<double, size_t> MeanCenterTestD_i64;
-TEST_P(MeanCenterTestD_i64, Result) {
-  ASSERT_TRUE(devArrMatch(out, out_ref, params.cols,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MeanCenterTests, MeanCenterTestD_i64,
-                        ::testing::ValuesIn(inputsd_i64));
-
-}  // end namespace stats
-}  // end namespace raft
diff --git a/cpp/test/prims/minmax.cu b/cpp/test/prims/minmax.cu
index 4e830d4a85..09b5842d53 100644
--- a/cpp/test/prims/minmax.cu
+++ b/cpp/test/prims/minmax.cu
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <cuda_utils.cuh>
 #include <limits>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <stats/minmax.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/multiply.cu b/cpp/test/prims/multiply.cu
deleted file mode 100644
index 2c7fff6248..0000000000
--- a/cpp/test/prims/multiply.cu
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/multiply.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-class MultiplyTest : public ::testing::TestWithParam<UnaryOpInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<UnaryOpInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    raft::allocate(in, len);
-    raft::allocate(out_ref, len);
-    raft::allocate(out, len);
-    r.uniform(in, len, T(-1.0), T(1.0), stream);
-    naiveScale(out_ref, in, params.scalar, len, stream);
-    multiplyScalar(out, in, params.scalar, len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  UnaryOpInputs<T> params;
-  T *in, *out_ref, *out;
-};
-
-const std::vector<UnaryOpInputs<float>> inputsf = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-typedef MultiplyTest<float> MultiplyTestF;
-TEST_P(MultiplyTestF, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MultiplyTests, MultiplyTestF,
-                        ::testing::ValuesIn(inputsf));
-
-typedef MultiplyTest<double> MultiplyTestD;
-const std::vector<UnaryOpInputs<double>> inputsd = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-TEST_P(MultiplyTestD, Result) {
-  ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(MultiplyTests, MultiplyTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/mutualInfoScore.cu b/cpp/test/prims/mutualInfoScore.cu
index fae189aa33..bf3e0894d0 100644
--- a/cpp/test/prims/mutualInfoScore.cu
+++ b/cpp/test/prims/mutualInfoScore.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/mvg.cu b/cpp/test/prims/mvg.cu
index 2d93da6eef..840d40d35f 100644
--- a/cpp/test/prims/mvg.cu
+++ b/cpp/test/prims/mvg.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <cmath>
 #include <iostream>
 #include <random/mvg.cuh>
diff --git a/cpp/test/prims/norm.cu b/cpp/test/prims/norm.cu
deleted file mode 100644
index 7fd45793fb..0000000000
--- a/cpp/test/prims/norm.cu
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/norm.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct NormInputs {
-  T tolerance;
-  int rows, cols;
-  NormType type;
-  bool do_sqrt;
-  bool rowMajor;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const NormInputs<T> &I) {
-  os << "{ " << I.tolerance << ", " << I.rows << ", " << I.cols << ", "
-     << I.type << ", " << I.do_sqrt << ", " << I.seed << '}' << std::endl;
-  return os;
-}
-
-///// Row-wise norm test definitions
-template <typename Type>
-__global__ void naiveRowNormKernel(Type *dots, const Type *data, int D, int N,
-                                   NormType type, bool do_sqrt) {
-  Type acc = (Type)0;
-  int rowStart = threadIdx.x + blockIdx.x * blockDim.x;
-  if (rowStart < N) {
-    for (int i = 0; i < D; ++i) {
-      if (type == L2Norm) {
-        acc += data[rowStart * D + i] * data[rowStart * D + i];
-      } else {
-        acc += raft::myAbs(data[rowStart * D + i]);
-      }
-    }
-    dots[rowStart] = do_sqrt ? raft::mySqrt(acc) : acc;
-  }
-}
-
-template <typename Type>
-void naiveRowNorm(Type *dots, const Type *data, int D, int N, NormType type,
-                  bool do_sqrt, cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(N, TPB);
-  naiveRowNormKernel<Type>
-    <<<nblks, TPB, 0, stream>>>(dots, data, D, N, type, do_sqrt);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-class RowNormTest : public ::testing::TestWithParam<NormInputs<T>> {
- public:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    params = ::testing::TestWithParam<NormInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols, len = rows * cols;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(data, len);
-    raft::allocate(dots_exp, rows);
-    raft::allocate(dots_act, rows);
-    r.uniform(data, len, T(-1.0), T(1.0), stream);
-    naiveRowNorm(dots_exp, data, cols, rows, params.type, params.do_sqrt,
-                 stream);
-    if (params.do_sqrt) {
-      auto fin_op = [] __device__(T in) { return raft::mySqrt(in); };
-      rowNorm(dots_act, data, cols, rows, params.type, params.rowMajor, stream,
-              fin_op);
-    } else {
-      rowNorm(dots_act, data, cols, rows, params.type, params.rowMajor, stream);
-    }
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(dots_exp));
-    CUDA_CHECK(cudaFree(dots_act));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
- protected:
-  NormInputs<T> params;
-  T *data, *dots_exp, *dots_act;
-  cudaStream_t stream;
-};
-
-///// Column-wise norm test definitisons
-template <typename Type>
-__global__ void naiveColNormKernel(Type *dots, const Type *data, int D, int N,
-                                   NormType type, bool do_sqrt) {
-  int colID = threadIdx.x + blockIdx.x * blockDim.x;
-  if (colID > D) return;  //avoid out-of-bounds thread
-
-  Type acc = 0;
-  for (int i = 0; i < N; i++) {
-    Type v = data[colID + i * D];
-    acc += type == L2Norm ? v * v : raft::myAbs(v);
-  }
-
-  dots[colID] = do_sqrt ? raft::mySqrt(acc) : acc;
-}
-
-template <typename Type>
-void naiveColNorm(Type *dots, const Type *data, int D, int N, NormType type,
-                  bool do_sqrt, cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(D, TPB);
-  naiveColNormKernel<Type>
-    <<<nblks, TPB, 0, stream>>>(dots, data, D, N, type, do_sqrt);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-class ColNormTest : public ::testing::TestWithParam<NormInputs<T>> {
- public:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    params = ::testing::TestWithParam<NormInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols, len = rows * cols;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(data, len);
-    r.uniform(data, len, T(-1.0), T(1.0), stream);
-    raft::allocate(dots_exp, cols);
-    raft::allocate(dots_act, cols);
-
-    naiveColNorm(dots_exp, data, cols, rows, params.type, params.do_sqrt,
-                 stream);
-    if (params.do_sqrt) {
-      auto fin_op = [] __device__(T in) { return raft::mySqrt(in); };
-      colNorm(dots_act, data, cols, rows, params.type, params.rowMajor, stream,
-              fin_op);
-    } else {
-      colNorm(dots_act, data, cols, rows, params.type, params.rowMajor, stream);
-    }
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(dots_exp));
-    CUDA_CHECK(cudaFree(dots_act));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
- protected:
-  NormInputs<T> params;
-  T *data, *dots_exp, *dots_act;
-  cudaStream_t stream;
-};
-
-///// Row- and column-wise tests
-const std::vector<NormInputs<float>> inputsf = {
-  {0.00001f, 1024, 32, L1Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 64, L1Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 128, L1Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 256, L1Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 32, L2Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 64, L2Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 128, L2Norm, false, true, 1234ULL},
-  {0.00001f, 1024, 256, L2Norm, false, true, 1234ULL},
-
-  {0.00001f, 1024, 32, L1Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 64, L1Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 128, L1Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 256, L1Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 32, L2Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 64, L2Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 128, L2Norm, true, true, 1234ULL},
-  {0.00001f, 1024, 256, L2Norm, true, true, 1234ULL}};
-
-const std::vector<NormInputs<double>> inputsd = {
-  {0.00000001, 1024, 32, L1Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 64, L1Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 128, L1Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 256, L1Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 32, L2Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 64, L2Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 128, L2Norm, false, true, 1234ULL},
-  {0.00000001, 1024, 256, L2Norm, false, true, 1234ULL},
-
-  {0.00000001, 1024, 32, L1Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 64, L1Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 128, L1Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 256, L1Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 32, L2Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 64, L2Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 128, L2Norm, true, true, 1234ULL},
-  {0.00000001, 1024, 256, L2Norm, true, true, 1234ULL}};
-
-typedef RowNormTest<float> RowNormTestF;
-TEST_P(RowNormTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.rows,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef RowNormTest<double> RowNormTestD;
-TEST_P(RowNormTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.rows,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(RowNormTests, RowNormTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(RowNormTests, RowNormTestD,
-                        ::testing::ValuesIn(inputsd));
-
-const std::vector<NormInputs<float>> inputscf = {
-  {0.00001f, 32, 1024, L1Norm, false, true, 1234ULL},
-  {0.00001f, 64, 1024, L1Norm, false, true, 1234ULL},
-  {0.00001f, 128, 1024, L1Norm, false, true, 1234ULL},
-  {0.00001f, 256, 1024, L1Norm, false, true, 1234ULL},
-  {0.00001f, 32, 1024, L2Norm, false, true, 1234ULL},
-  {0.00001f, 64, 1024, L2Norm, false, true, 1234ULL},
-  {0.00001f, 128, 1024, L2Norm, false, true, 1234ULL},
-  {0.00001f, 256, 1024, L2Norm, false, true, 1234ULL},
-
-  {0.00001f, 32, 1024, L1Norm, true, true, 1234ULL},
-  {0.00001f, 64, 1024, L1Norm, true, true, 1234ULL},
-  {0.00001f, 128, 1024, L1Norm, true, true, 1234ULL},
-  {0.00001f, 256, 1024, L1Norm, true, true, 1234ULL},
-  {0.00001f, 32, 1024, L2Norm, true, true, 1234ULL},
-  {0.00001f, 64, 1024, L2Norm, true, true, 1234ULL},
-  {0.00001f, 128, 1024, L2Norm, true, true, 1234ULL},
-  {0.00001f, 256, 1024, L2Norm, true, true, 1234ULL}};
-
-const std::vector<NormInputs<double>> inputscd = {
-  {0.00000001, 32, 1024, L1Norm, false, true, 1234ULL},
-  {0.00000001, 64, 1024, L1Norm, false, true, 1234ULL},
-  {0.00000001, 128, 1024, L1Norm, false, true, 1234ULL},
-  {0.00000001, 256, 1024, L1Norm, false, true, 1234ULL},
-  {0.00000001, 32, 1024, L2Norm, false, true, 1234ULL},
-  {0.00000001, 64, 1024, L2Norm, false, true, 1234ULL},
-  {0.00000001, 128, 1024, L2Norm, false, true, 1234ULL},
-  {0.00000001, 256, 1024, L2Norm, false, true, 1234ULL},
-
-  {0.00000001, 32, 1024, L1Norm, true, true, 1234ULL},
-  {0.00000001, 64, 1024, L1Norm, true, true, 1234ULL},
-  {0.00000001, 128, 1024, L1Norm, true, true, 1234ULL},
-  {0.00000001, 256, 1024, L1Norm, true, true, 1234ULL},
-  {0.00000001, 32, 1024, L2Norm, true, true, 1234ULL},
-  {0.00000001, 64, 1024, L2Norm, true, true, 1234ULL},
-  {0.00000001, 128, 1024, L2Norm, true, true, 1234ULL},
-  {0.00000001, 256, 1024, L2Norm, true, true, 1234ULL}};
-
-typedef ColNormTest<float> ColNormTestF;
-TEST_P(ColNormTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.cols,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef ColNormTest<double> ColNormTestD;
-TEST_P(ColNormTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(dots_exp, dots_act, params.cols,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(ColNormTests, ColNormTestF,
-                        ::testing::ValuesIn(inputscf));
-
-INSTANTIATE_TEST_CASE_P(ColNormTests, ColNormTestD,
-                        ::testing::ValuesIn(inputscd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/penalty.cu b/cpp/test/prims/penalty.cu
index 596255171d..1c5a3190d2 100644
--- a/cpp/test/prims/penalty.cu
+++ b/cpp/test/prims/penalty.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <functions/penalty.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/permute.cu b/cpp/test/prims/permute.cu
index 5d5fd0b6d8..99d95e53c6 100644
--- a/cpp/test/prims/permute.cu
+++ b/cpp/test/prims/permute.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <random/permute.cuh>
-#include <random/rng.cuh>
 #include <vector>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/power.cu b/cpp/test/prims/power.cu
index ab85545181..7bf5bd5688 100644
--- a/cpp/test/prims/power.cu
+++ b/cpp/test/prims/power.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <linalg/power.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/randIndex.cu b/cpp/test/prims/randIndex.cu
index 3013c0ab4f..d44d6babf4 100644
--- a/cpp/test/prims/randIndex.cu
+++ b/cpp/test/prims/randIndex.cu
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/reduce.cu b/cpp/test/prims/reduce.cu
deleted file mode 100644
index fe17615aa2..0000000000
--- a/cpp/test/prims/reduce.cu
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/reduce.cuh>
-#include <random/rng.cuh>
-#include "reduce.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct ReduceInputs {
-  T tolerance;
-  int rows, cols;
-  bool rowMajor, alongRows;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const ReduceInputs<T> &dims) {
-  return os;
-}
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename T>
-void reduceLaunch(T *dots, const T *data, int cols, int rows, bool rowMajor,
-                  bool alongRows, bool inplace, cudaStream_t stream) {
-  reduce(dots, data, cols, rows, (T)0, rowMajor, alongRows, stream, inplace,
-         [] __device__(T in, int i) { return in * in; });
-}
-
-template <typename T>
-class ReduceTest : public ::testing::TestWithParam<ReduceInputs<T>> {
- protected:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    params = ::testing::TestWithParam<ReduceInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-    outlen = params.alongRows ? rows : cols;
-    raft::allocate(data, len);
-    raft::allocate(dots_exp, outlen);
-    raft::allocate(dots_act, outlen);
-    r.uniform(data, len, T(-1.0), T(1.0), stream);
-    naiveReduction(dots_exp, data, cols, rows, params.rowMajor,
-                   params.alongRows, stream);
-
-    // Perform reduction with default inplace = false first
-    reduceLaunch(dots_act, data, cols, rows, params.rowMajor, params.alongRows,
-                 false, stream);
-    // Add to result with inplace = true next, which shouldn't affect
-    // in the case of coalescedReduction!
-    if (!(params.rowMajor ^ params.alongRows)) {
-      reduceLaunch(dots_act, data, cols, rows, params.rowMajor,
-                   params.alongRows, true, stream);
-    }
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(dots_exp));
-    CUDA_CHECK(cudaFree(dots_act));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
- protected:
-  ReduceInputs<T> params;
-  T *data, *dots_exp, *dots_act;
-  int outlen;
-  cudaStream_t stream;
-};
-
-const std::vector<ReduceInputs<float>> inputsf = {
-  {0.000002f, 1024, 32, true, true, 1234ULL},
-  {0.000002f, 1024, 64, true, true, 1234ULL},
-  {0.000002f, 1024, 128, true, true, 1234ULL},
-  {0.000002f, 1024, 256, true, true, 1234ULL},
-  {0.000002f, 1024, 32, true, false, 1234ULL},
-  {0.000002f, 1024, 64, true, false, 1234ULL},
-  {0.000002f, 1024, 128, true, false, 1234ULL},
-  {0.000002f, 1024, 256, true, false, 1234ULL},
-  {0.000002f, 1024, 32, false, true, 1234ULL},
-  {0.000002f, 1024, 64, false, true, 1234ULL},
-  {0.000002f, 1024, 128, false, true, 1234ULL},
-  {0.000002f, 1024, 256, false, true, 1234ULL},
-  {0.000002f, 1024, 32, false, false, 1234ULL},
-  {0.000002f, 1024, 64, false, false, 1234ULL},
-  {0.000002f, 1024, 128, false, false, 1234ULL},
-  {0.000002f, 1024, 256, false, false, 1234ULL}};
-
-const std::vector<ReduceInputs<double>> inputsd = {
-  {0.000000001, 1024, 32, true, true, 1234ULL},
-  {0.000000001, 1024, 64, true, true, 1234ULL},
-  {0.000000001, 1024, 128, true, true, 1234ULL},
-  {0.000000001, 1024, 256, true, true, 1234ULL},
-  {0.000000001, 1024, 32, true, false, 1234ULL},
-  {0.000000001, 1024, 64, true, false, 1234ULL},
-  {0.000000001, 1024, 128, true, false, 1234ULL},
-  {0.000000001, 1024, 256, true, false, 1234ULL},
-  {0.000000001, 1024, 32, false, true, 1234ULL},
-  {0.000000001, 1024, 64, false, true, 1234ULL},
-  {0.000000001, 1024, 128, false, true, 1234ULL},
-  {0.000000001, 1024, 256, false, true, 1234ULL},
-  {0.000000001, 1024, 32, false, false, 1234ULL},
-  {0.000000001, 1024, 64, false, false, 1234ULL},
-  {0.000000001, 1024, 128, false, false, 1234ULL},
-  {0.000000001, 1024, 256, false, false, 1234ULL}};
-
-typedef ReduceTest<float> ReduceTestF;
-TEST_P(ReduceTestF, Result) {
-  ASSERT_TRUE(devArrMatch(dots_exp, dots_act, outlen,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef ReduceTest<double> ReduceTestD;
-TEST_P(ReduceTestD, Result) {
-  ASSERT_TRUE(devArrMatch(dots_exp, dots_act, outlen,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(ReduceTests, ReduceTestF, ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(ReduceTests, ReduceTestD, ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/reduce.cuh b/cpp/test/prims/reduce.cuh
deleted file mode 100644
index bac0f0edaf..0000000000
--- a/cpp/test/prims/reduce.cuh
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <cublas_v2.h>
-#include <raft/linalg/cublas_wrappers.h>
-#include <thrust/device_vector.h>
-#include <cuda_utils.cuh>
-#include <linalg/unary_op.cuh>
-
-namespace raft {
-namespace linalg {
-
-template <typename Type>
-__global__ void naiveCoalescedReductionKernel(Type *dots, const Type *data,
-                                              int D, int N) {
-  Type acc = (Type)0;
-  int rowStart = threadIdx.x + blockIdx.x * blockDim.x;
-  if (rowStart < N) {
-    for (int i = 0; i < D; ++i) {
-      acc += data[rowStart * D + i] * data[rowStart * D + i];
-    }
-    dots[rowStart] = 2 * acc;
-  }
-}
-
-template <typename Type>
-void naiveCoalescedReduction(Type *dots, const Type *data, int D, int N,
-                             cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(N, TPB);
-  naiveCoalescedReductionKernel<Type>
-    <<<nblks, TPB, 0, stream>>>(dots, data, D, N);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type>
-void unaryAndGemv(Type *dots, const Type *data, int D, int N,
-                  cudaStream_t stream) {
-  //computes a MLCommon unary op on data (squares it), then computes Ax
-  //(A input matrix and x column vector) to sum columns
-  thrust::device_vector<Type> sq(D * N);
-  raft::linalg::unaryOp(
-    thrust::raw_pointer_cast(sq.data()), data, D * N,
-    [] __device__(Type v) { return v * v; }, stream);
-  cublasHandle_t handle;
-  CUBLAS_CHECK(cublasCreate(&handle));
-  thrust::device_vector<Type> ones(N, 1);  //column vector [1...1]
-  Type alpha = 1, beta = 0;
-  CUBLAS_CHECK(raft::linalg::cublasgemv(
-    handle, CUBLAS_OP_N, D, N, &alpha, thrust::raw_pointer_cast(sq.data()), D,
-    thrust::raw_pointer_cast(ones.data()), 1, &beta, dots, 1, stream));
-  CUDA_CHECK(cudaDeviceSynchronize());
-  CUBLAS_CHECK(cublasDestroy(handle));
-}
-
-template <typename Type>
-void naiveReduction(Type *dots, const Type *data, int D, int N, bool rowMajor,
-                    bool alongRows, cudaStream_t stream) {
-  if (rowMajor && alongRows) {
-    naiveCoalescedReduction(dots, data, D, N, stream);
-  } else if (rowMajor && !alongRows) {
-    unaryAndGemv(dots, data, D, N, stream);
-  } else if (!rowMajor && alongRows) {
-    unaryAndGemv(dots, data, N, D, stream);
-  } else {
-    naiveCoalescedReduction(dots, data, N, D, stream);
-  }
-  CUDA_CHECK(cudaDeviceSynchronize());
-}
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/reduce_cols_by_key.cu b/cpp/test/prims/reduce_cols_by_key.cu
index 33e48edd19..777973c205 100644
--- a/cpp/test/prims/reduce_cols_by_key.cu
+++ b/cpp/test/prims/reduce_cols_by_key.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <linalg/reduce_cols_by_key.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/reduce_rows_by_key.cu b/cpp/test/prims/reduce_rows_by_key.cu
index 74c9515a30..ec066600ab 100644
--- a/cpp/test/prims/reduce_rows_by_key.cu
+++ b/cpp/test/prims/reduce_rows_by_key.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <iostream>
 #include <linalg/reduce_rows_by_key.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/reverse.cu b/cpp/test/prims/reverse.cu
index 9fece2c038..6ff8bdd918 100644
--- a/cpp/test/prims/reverse.cu
+++ b/cpp/test/prims/reverse.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <matrix/reverse.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/rng.cu b/cpp/test/prims/rng.cu
deleted file mode 100644
index 6259bc1287..0000000000
--- a/cpp/test/prims/rng.cu
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include <stats/mean.cuh>
-#include <stats/stddev.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace random {
-
-enum RandomType {
-  RNG_Normal,
-  RNG_LogNormal,
-  RNG_Uniform,
-  RNG_Gumbel,
-  RNG_Logistic,
-  RNG_Exp,
-  RNG_Rayleigh,
-  RNG_Laplace
-};
-
-template <typename T, int TPB>
-__global__ void meanKernel(T* out, const T* data, int len) {
-  typedef cub::BlockReduce<T, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  int tid = threadIdx.x + blockIdx.x * blockDim.x;
-  T val = tid < len ? data[tid] : T(0);
-  T x = BlockReduce(temp_storage).Sum(val);
-  __syncthreads();
-  T xx = BlockReduce(temp_storage).Sum(val * val);
-  __syncthreads();
-  if (threadIdx.x == 0) {
-    raft::myAtomicAdd(out, x);
-    raft::myAtomicAdd(out + 1, xx);
-  }
-}
-
-template <typename T>
-struct RngInputs {
-  T tolerance;
-  int len;
-  // start, end: for uniform
-  // mean, sigma: for normal/lognormal
-  // mean, beta: for gumbel
-  // mean, scale: for logistic and laplace
-  // lambda: for exponential
-  // sigma: for rayleigh
-  T start, end;
-  RandomType type;
-  GeneratorType gtype;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream& operator<<(::std::ostream& os, const RngInputs<T>& dims) {
-  return os;
-}
-
-#include <sys/timeb.h>
-#include <time.h>
-
-template <typename T>
-class RngTest : public ::testing::TestWithParam<RngInputs<T>> {
- protected:
-  void SetUp() override {
-    // Tests are configured with their expected test-values sigma. For example,
-    // 4 x sigma indicates the test shouldn't fail 99.9% of the time.
-    num_sigma = 10;
-    params = ::testing::TestWithParam<RngInputs<T>>::GetParam();
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    Rng r(params.seed, params.gtype);
-    allocate(data, params.len);
-    allocate(stats, 2, true);
-    switch (params.type) {
-      case RNG_Normal:
-        r.normal(data, params.len, params.start, params.end, stream);
-        break;
-      case RNG_LogNormal:
-        r.lognormal(data, params.len, params.start, params.end, stream);
-        break;
-      case RNG_Uniform:
-        r.uniform(data, params.len, params.start, params.end, stream);
-        break;
-      case RNG_Gumbel:
-        r.gumbel(data, params.len, params.start, params.end, stream);
-        break;
-      case RNG_Logistic:
-        r.logistic(data, params.len, params.start, params.end, stream);
-        break;
-      case RNG_Exp:
-        r.exponential(data, params.len, params.start, stream);
-        break;
-      case RNG_Rayleigh:
-        r.rayleigh(data, params.len, params.start, stream);
-        break;
-      case RNG_Laplace:
-        r.laplace(data, params.len, params.start, params.end, stream);
-        break;
-    };
-    static const int threads = 128;
-    meanKernel<T, threads>
-      <<<raft::ceildiv(params.len, threads), threads, 0, stream>>>(stats, data,
-                                                                   params.len);
-    update_host<T>(h_stats, stats, 2, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    h_stats[0] /= params.len;
-    h_stats[1] = (h_stats[1] / params.len) - (h_stats[0] * h_stats[0]);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(stats));
-  }
-
-  void getExpectedMeanVar(T meanvar[2]) {
-    switch (params.type) {
-      case RNG_Normal:
-        meanvar[0] = params.start;
-        meanvar[1] = params.end * params.end;
-        break;
-      case RNG_LogNormal: {
-        auto var = params.end * params.end;
-        auto mu = params.start;
-        meanvar[0] = raft::myExp(mu + var * T(0.5));
-        meanvar[1] =
-          (raft::myExp(var) - T(1.0)) * raft::myExp(T(2.0) * mu + var);
-        break;
-      }
-      case RNG_Uniform:
-        meanvar[0] = (params.start + params.end) * T(0.5);
-        meanvar[1] = params.end - params.start;
-        meanvar[1] = meanvar[1] * meanvar[1] / T(12.0);
-        break;
-      case RNG_Gumbel: {
-        auto gamma = T(0.577215664901532);
-        meanvar[0] = params.start + params.end * gamma;
-        meanvar[1] = T(3.1415) * T(3.1415) * params.end * params.end / T(6.0);
-        break;
-      }
-      case RNG_Logistic:
-        meanvar[0] = params.start;
-        meanvar[1] = T(3.1415) * T(3.1415) * params.end * params.end / T(3.0);
-        break;
-      case RNG_Exp:
-        meanvar[0] = T(1.0) / params.start;
-        meanvar[1] = meanvar[0] * meanvar[0];
-        break;
-      case RNG_Rayleigh:
-        meanvar[0] = params.start * raft::mySqrt(T(3.1415 / 2.0));
-        meanvar[1] =
-          ((T(4.0) - T(3.1415)) / T(2.0)) * params.start * params.start;
-        break;
-      case RNG_Laplace:
-        meanvar[0] = params.start;
-        meanvar[1] = T(2.0) * params.end * params.end;
-        break;
-    };
-  }
-
- protected:
-  RngInputs<T> params;
-  T *data, *stats;
-  T h_stats[2];  // mean, var
-  int num_sigma;
-};
-
-// The measured mean and standard deviation for each tested distribution are,
-// of course, statistical variables. Thus setting an appropriate testing
-// tolerance essentially requires one to set a probability of test failure. We
-// choose to set this at 3-4 x sigma, i.e., a 99.7-99.9% confidence interval so that
-// the test will indeed pass. In quick experiments (using the identical
-// distributions given by NumPy/SciPy), the measured standard deviation is the
-// variable with the greatest variance and so we determined the variance for
-// each distribution and number of samples (32*1024 or 8*1024). Below
-// are listed the standard deviation for these tests.
-
-// Distribution: StdDev 32*1024, StdDev 8*1024
-// Normal: 0.0055, 0.011
-// LogNormal: 0.05, 0.1
-// Uniform: 0.003, 0.005
-// Gumbel: 0.005, 0.01
-// Logistic: 0.005, 0.01
-// Exp: 0.008, 0.015
-// Rayleigh: 0.0125, 0.025
-// Laplace: 0.02, 0.04
-
-// We generally want 4 x sigma >= 99.9% chance of success
-
-typedef RngTest<float> RngTestF;
-const std::vector<RngInputs<float>> inputsf = {
-  {0.0055, 32 * 1024, 1.f, 1.f, RNG_Normal, GenPhilox, 1234ULL},
-  {0.011, 8 * 1024, 1.f, 1.f, RNG_Normal, GenPhilox, 1234ULL},
-  {0.05, 32 * 1024, 1.f, 1.f, RNG_LogNormal, GenPhilox, 1234ULL},
-  {0.1, 8 * 1024, 1.f, 1.f, RNG_LogNormal, GenPhilox, 1234ULL},
-  {0.003, 32 * 1024, -1.f, 1.f, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.005, 8 * 1024, -1.f, 1.f, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Gumbel, GenPhilox, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Gumbel, GenPhilox, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Logistic, GenPhilox, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Logistic, GenPhilox, 1234ULL},
-  {0.008, 32 * 1024, 1.f, 1.f, RNG_Exp, GenPhilox, 1234ULL},
-  {0.015, 8 * 1024, 1.f, 1.f, RNG_Exp, GenPhilox, 1234ULL},
-  {0.0125, 32 * 1024, 1.f, 1.f, RNG_Rayleigh, GenPhilox, 1234ULL},
-  {0.025, 8 * 1024, 1.f, 1.f, RNG_Rayleigh, GenPhilox, 1234ULL},
-  {0.02, 32 * 1024, 1.f, 1.f, RNG_Laplace, GenPhilox, 1234ULL},
-  {0.04, 8 * 1024, 1.f, 1.f, RNG_Laplace, GenPhilox, 1234ULL},
-
-  {0.0055, 32 * 1024, 1.f, 1.f, RNG_Normal, GenTaps, 1234ULL},
-  {0.011, 8 * 1024, 1.f, 1.f, RNG_Normal, GenTaps, 1234ULL},
-  {0.05, 32 * 1024, 1.f, 1.f, RNG_LogNormal, GenTaps, 1234ULL},
-  {0.1, 8 * 1024, 1.f, 1.f, RNG_LogNormal, GenTaps, 1234ULL},
-  {0.003, 32 * 1024, -1.f, 1.f, RNG_Uniform, GenTaps, 1234ULL},
-  {0.005, 8 * 1024, -1.f, 1.f, RNG_Uniform, GenTaps, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Gumbel, GenTaps, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Gumbel, GenTaps, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Logistic, GenTaps, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Logistic, GenTaps, 1234ULL},
-  {0.008, 32 * 1024, 1.f, 1.f, RNG_Exp, GenTaps, 1234ULL},
-  {0.015, 8 * 1024, 1.f, 1.f, RNG_Exp, GenTaps, 1234ULL},
-  {0.0125, 32 * 1024, 1.f, 1.f, RNG_Rayleigh, GenTaps, 1234ULL},
-  {0.025, 8 * 1024, 1.f, 1.f, RNG_Rayleigh, GenTaps, 1234ULL},
-  {0.02, 32 * 1024, 1.f, 1.f, RNG_Laplace, GenTaps, 1234ULL},
-  {0.04, 8 * 1024, 1.f, 1.f, RNG_Laplace, GenTaps, 1234ULL},
-
-  {0.0055, 32 * 1024, 1.f, 1.f, RNG_Normal, GenKiss99, 1234ULL},
-  {0.011, 8 * 1024, 1.f, 1.f, RNG_Normal, GenKiss99, 1234ULL},
-  {0.05, 32 * 1024, 1.f, 1.f, RNG_LogNormal, GenKiss99, 1234ULL},
-  {0.1, 8 * 1024, 1.f, 1.f, RNG_LogNormal, GenKiss99, 1234ULL},
-  {0.003, 32 * 1024, -1.f, 1.f, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.005, 8 * 1024, -1.f, 1.f, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Gumbel, GenKiss99, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Gumbel, GenKiss99, 1234ULL},
-  {0.005, 32 * 1024, 1.f, 1.f, RNG_Logistic, GenKiss99, 1234ULL},
-  {0.01, 8 * 1024, 1.f, 1.f, RNG_Logistic, GenKiss99, 1234ULL},
-  {0.008, 32 * 1024, 1.f, 1.f, RNG_Exp, GenKiss99, 1234ULL},
-  {0.015, 8 * 1024, 1.f, 1.f, RNG_Exp, GenKiss99, 1234ULL},
-  {0.0125, 32 * 1024, 1.f, 1.f, RNG_Rayleigh, GenKiss99, 1234ULL},
-  {0.025, 8 * 1024, 1.f, 1.f, RNG_Rayleigh, GenKiss99, 1234ULL},
-  {0.02, 32 * 1024, 1.f, 1.f, RNG_Laplace, GenKiss99, 1234ULL},
-  {0.04, 8 * 1024, 1.f, 1.f, RNG_Laplace, GenKiss99, 1234ULL}};
-
-TEST_P(RngTestF, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(match(meanvar[0], h_stats[0],
-                    CompareApprox<float>(num_sigma * params.tolerance)));
-  ASSERT_TRUE(match(meanvar[1], h_stats[1],
-                    CompareApprox<float>(num_sigma * params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestF, ::testing::ValuesIn(inputsf));
-
-typedef RngTest<double> RngTestD;
-const std::vector<RngInputs<double>> inputsd = {
-  {0.0055, 32 * 1024, 1.0, 1.0, RNG_Normal, GenPhilox, 1234ULL},
-  {0.011, 8 * 1024, 1.0, 1.0, RNG_Normal, GenPhilox, 1234ULL},
-  {0.05, 32 * 1024, 1.0, 1.0, RNG_LogNormal, GenPhilox, 1234ULL},
-  {0.1, 8 * 1024, 1.0, 1.0, RNG_LogNormal, GenPhilox, 1234ULL},
-  {0.003, 32 * 1024, -1.0, 1.0, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.005, 8 * 1024, -1.0, 1.0, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Gumbel, GenPhilox, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Gumbel, GenPhilox, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Logistic, GenPhilox, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Logistic, GenPhilox, 1234ULL},
-  {0.008, 32 * 1024, 1.0, 1.0, RNG_Exp, GenPhilox, 1234ULL},
-  {0.015, 8 * 1024, 1.0, 1.0, RNG_Exp, GenPhilox, 1234ULL},
-  {0.0125, 32 * 1024, 1.0, 1.0, RNG_Rayleigh, GenPhilox, 1234ULL},
-  {0.025, 8 * 1024, 1.0, 1.0, RNG_Rayleigh, GenPhilox, 1234ULL},
-  {0.02, 32 * 1024, 1.0, 1.0, RNG_Laplace, GenPhilox, 1234ULL},
-  {0.04, 8 * 1024, 1.0, 1.0, RNG_Laplace, GenPhilox, 1234ULL},
-
-  {0.0055, 32 * 1024, 1.0, 1.0, RNG_Normal, GenTaps, 1234ULL},
-  {0.011, 8 * 1024, 1.0, 1.0, RNG_Normal, GenTaps, 1234ULL},
-  {0.05, 32 * 1024, 1.0, 1.0, RNG_LogNormal, GenTaps, 1234ULL},
-  {0.1, 8 * 1024, 1.0, 1.0, RNG_LogNormal, GenTaps, 1234ULL},
-  {0.003, 32 * 1024, -1.0, 1.0, RNG_Uniform, GenTaps, 1234ULL},
-  {0.005, 8 * 1024, -1.0, 1.0, RNG_Uniform, GenTaps, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Gumbel, GenTaps, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Gumbel, GenTaps, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Logistic, GenTaps, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Logistic, GenTaps, 1234ULL},
-  {0.008, 32 * 1024, 1.0, 1.0, RNG_Exp, GenTaps, 1234ULL},
-  {0.015, 8 * 1024, 1.0, 1.0, RNG_Exp, GenTaps, 1234ULL},
-  {0.0125, 32 * 1024, 1.0, 1.0, RNG_Rayleigh, GenTaps, 1234ULL},
-  {0.025, 8 * 1024, 1.0, 1.0, RNG_Rayleigh, GenTaps, 1234ULL},
-  {0.02, 32 * 1024, 1.0, 1.0, RNG_Laplace, GenTaps, 1234ULL},
-  {0.04, 8 * 1024, 1.0, 1.0, RNG_Laplace, GenTaps, 1234ULL},
-
-  {0.0055, 32 * 1024, 1.0, 1.0, RNG_Normal, GenKiss99, 1234ULL},
-  {0.011, 8 * 1024, 1.0, 1.0, RNG_Normal, GenKiss99, 1234ULL},
-  {0.05, 32 * 1024, 1.0, 1.0, RNG_LogNormal, GenKiss99, 1234ULL},
-  {0.1, 8 * 1024, 1.0, 1.0, RNG_LogNormal, GenKiss99, 1234ULL},
-  {0.003, 32 * 1024, -1.0, 1.0, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.005, 8 * 1024, -1.0, 1.0, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Gumbel, GenKiss99, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Gumbel, GenKiss99, 1234ULL},
-  {0.005, 32 * 1024, 1.0, 1.0, RNG_Logistic, GenKiss99, 1234ULL},
-  {0.01, 8 * 1024, 1.0, 1.0, RNG_Logistic, GenKiss99, 1234ULL},
-  {0.008, 32 * 1024, 1.0, 1.0, RNG_Exp, GenKiss99, 1234ULL},
-  {0.015, 8 * 1024, 1.0, 1.0, RNG_Exp, GenKiss99, 1234ULL},
-  {0.0125, 32 * 1024, 1.0, 1.0, RNG_Rayleigh, GenKiss99, 1234ULL},
-  {0.025, 8 * 1024, 1.0, 1.0, RNG_Rayleigh, GenKiss99, 1234ULL},
-  {0.02, 32 * 1024, 1.0, 1.0, RNG_Laplace, GenKiss99, 1234ULL},
-  {0.04, 8 * 1024, 1.0, 1.0, RNG_Laplace, GenKiss99, 1234ULL}};
-TEST_P(RngTestD, Result) {
-  double meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(match(meanvar[0], h_stats[0],
-                    CompareApprox<double>(num_sigma * params.tolerance)));
-  ASSERT_TRUE(match(meanvar[1], h_stats[1],
-                    CompareApprox<double>(num_sigma * params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestD, ::testing::ValuesIn(inputsd));
-
-// ---------------------------------------------------------------------- //
-// Test for expected variance in mean calculations
-
-template <typename T>
-T quick_mean(const std::vector<T>& d) {
-  T acc = T(0);
-  for (const auto& di : d) {
-    acc += di;
-  }
-  return acc / d.size();
-}
-
-template <typename T>
-T quick_std(const std::vector<T>& d) {
-  T acc = T(0);
-  T d_mean = quick_mean(d);
-  for (const auto& di : d) {
-    acc += ((di - d_mean) * (di - d_mean));
-  }
-  return std::sqrt(acc / (d.size() - 1));
-}
-
-template <typename T>
-std::ostream& operator<<(std::ostream& out, const std::vector<T>& v) {
-  if (!v.empty()) {
-    out << '[';
-    std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
-    out << "\b\b]";
-  }
-  return out;
-}
-
-// The following tests the 3 random number generators by checking that the
-// measured mean error is close to the well-known analytical result
-// (sigma/sqrt(n_samples)). To compute the mean error, we a number of
-// experiments computing the mean, giving us a distribution of the mean
-// itself. The mean error is simply the standard deviation of this
-// distribution (the standard deviation of the mean).
-TEST(Rng, MeanError) {
-  timeb time_struct;
-  ftime(&time_struct);
-  int seed = time_struct.millitm;
-  int num_samples = 1024;
-  int num_experiments = 1024;
-  float* data;
-  float* mean_result;
-  float* std_result;
-  int len = num_samples * num_experiments;
-
-  cudaStream_t stream;
-  CUDA_CHECK(cudaStreamCreate(&stream));
-
-  allocate(data, len);
-  allocate(mean_result, num_experiments);
-  allocate(std_result, num_experiments);
-
-  for (auto rtype : {GenPhilox, GenKiss99 /*, raft::random::GenTaps */}) {
-    Rng r(seed, rtype);
-    r.normal(data, len, 3.3f, 0.23f, stream);
-    // r.uniform(data, len, -1.0, 2.0);
-    raft::stats::mean(mean_result, data, num_samples, num_experiments, false,
-                      false, stream);
-    raft::stats::stddev(std_result, data, mean_result, num_samples,
-                        num_experiments, false, false, stream);
-    std::vector<float> h_mean_result(num_experiments);
-    std::vector<float> h_std_result(num_experiments);
-    update_host(h_mean_result.data(), mean_result, num_experiments, stream);
-    update_host(h_std_result.data(), std_result, num_experiments, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    auto d_mean = quick_mean(h_mean_result);
-
-    // std-dev of mean; also known as mean error
-    auto d_std_of_mean = quick_std(h_mean_result);
-    auto d_std = quick_mean(h_std_result);
-    auto d_std_of_mean_analytical = d_std / std::sqrt(num_samples);
-
-    // std::cout << "measured mean error: " << d_std_of_mean << "\n";
-    // std::cout << "expected mean error: " << d_std/std::sqrt(num_samples) << "\n";
-
-    auto diff_expected_vs_measured_mean_error =
-      std::abs(d_std_of_mean - d_std / std::sqrt(num_samples));
-
-    ASSERT_TRUE(
-      (diff_expected_vs_measured_mean_error / d_std_of_mean_analytical < 0.5));
-  }
-  CUDA_CHECK(cudaStreamDestroy(stream));
-  CUDA_CHECK(cudaFree(data));
-  CUDA_CHECK(cudaFree(mean_result));
-  CUDA_CHECK(cudaFree(std_result));
-
-  // std::cout << "mean_res:" << h_mean_result << "\n";
-}
-
-template <typename T, int len, int scale>
-class ScaledBernoulliTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    Rng r(42);
-
-    allocate(data, len * sizeof(T), stream);
-    r.scaled_bernoulli(data, len, T(0.5), T(scale), stream);
-  }
-
-  void TearDown() override { CUDA_CHECK(cudaFree(data)); }
-
-  void rangeCheck() {
-    T* h_data = new T[len];
-    update_host(h_data, data, len, stream);
-    ASSERT_TRUE(std::none_of(h_data, h_data + len, [](const T& a) {
-      return a < -scale || a > scale;
-    }));
-    delete[] h_data;
-  }
-
-  T* data;
-  cudaStream_t stream;
-};
-
-typedef ScaledBernoulliTest<float, 500, 35> ScaledBernoulliTest1;
-TEST_F(ScaledBernoulliTest1, RangeCheck) { rangeCheck(); }
-
-typedef ScaledBernoulliTest<double, 100, 220> ScaledBernoulliTest2;
-TEST_F(ScaledBernoulliTest2, RangeCheck) { rangeCheck(); }
-
-template <typename T, int len>
-class BernoulliTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    Rng r(42);
-    allocate(data, len * sizeof(bool), stream);
-    r.bernoulli(data, len, T(0.5), stream);
-  }
-
-  void TearDown() override { CUDA_CHECK(cudaFree(data)); }
-
-  void trueFalseCheck() {
-    // both true and false values must be present
-    bool* h_data = new bool[len];
-    update_host(h_data, data, len, stream);
-    ASSERT_TRUE(std::any_of(h_data, h_data + len, [](bool a) { return a; }));
-    ASSERT_TRUE(std::any_of(h_data, h_data + len, [](bool a) { return !a; }));
-    delete[] h_data;
-  }
-
-  bool* data;
-  cudaStream_t stream;
-};
-
-typedef BernoulliTest<float, 1000> BernoulliTest1;
-TEST_F(BernoulliTest1, TrueFalseCheck) { trueFalseCheck(); }
-
-typedef BernoulliTest<double, 1000> BernoulliTest2;
-TEST_F(BernoulliTest2, TrueFalseCheck) { trueFalseCheck(); }
-
-/** Rng::normalTable tests */
-template <typename T>
-struct RngNormalTableInputs {
-  T tolerance;
-  int rows, cols;
-  T mu, sigma;
-  GeneratorType gtype;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream& operator<<(::std::ostream& os,
-                           const RngNormalTableInputs<T>& dims) {
-  return os;
-}
-
-template <typename T>
-class RngNormalTableTest
-  : public ::testing::TestWithParam<RngNormalTableInputs<T>> {
- protected:
-  void SetUp() override {
-    // Tests are configured with their expected test-values sigma. For example,
-    // 4 x sigma indicates the test shouldn't fail 99.9% of the time.
-    num_sigma = 10;
-    params = ::testing::TestWithParam<RngNormalTableInputs<T>>::GetParam();
-    int len = params.rows * params.cols;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    Rng r(params.seed, params.gtype);
-    allocate(data, len);
-    allocate(stats, 2, true);
-    allocate(mu_vec, params.cols);
-    r.fill(mu_vec, params.cols, params.mu, stream);
-    T* sigma_vec = nullptr;
-    r.normalTable(data, params.rows, params.cols, mu_vec, sigma_vec,
-                  params.sigma, stream);
-    static const int threads = 128;
-    meanKernel<T, threads>
-      <<<raft::ceildiv(len, threads), threads, 0, stream>>>(stats, data, len);
-    update_host<T>(h_stats, stats, 2, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    h_stats[0] /= len;
-    h_stats[1] = (h_stats[1] / len) - (h_stats[0] * h_stats[0]);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(stats));
-    CUDA_CHECK(cudaFree(mu_vec));
-  }
-
-  void getExpectedMeanVar(T meanvar[2]) {
-    meanvar[0] = params.mu;
-    meanvar[1] = params.sigma * params.sigma;
-  }
-
- protected:
-  RngNormalTableInputs<T> params;
-  T *data, *stats, *mu_vec;
-  T h_stats[2];  // mean, var
-  int num_sigma;
-};
-
-typedef RngNormalTableTest<float> RngNormalTableTestF;
-const std::vector<RngNormalTableInputs<float>> inputsf_t = {
-  {0.0055, 32, 1024, 1.f, 1.f, GenPhilox, 1234ULL},
-  {0.011, 8, 1024, 1.f, 1.f, GenPhilox, 1234ULL},
-  {0.0055, 32, 1024, 1.f, 1.f, GenTaps, 1234ULL},
-  {0.011, 8, 1024, 1.f, 1.f, GenTaps, 1234ULL},
-  {0.0055, 32, 1024, 1.f, 1.f, GenKiss99, 1234ULL},
-  {0.011, 8, 1024, 1.f, 1.f, GenKiss99, 1234ULL}};
-
-TEST_P(RngNormalTableTestF, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(match(meanvar[0], h_stats[0],
-                    CompareApprox<float>(num_sigma * params.tolerance)));
-  ASSERT_TRUE(match(meanvar[1], h_stats[1],
-                    CompareApprox<float>(num_sigma * params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngNormalTableTests, RngNormalTableTestF,
-                        ::testing::ValuesIn(inputsf_t));
-
-typedef RngNormalTableTest<double> RngNormalTableTestD;
-const std::vector<RngNormalTableInputs<double>> inputsd_t = {
-  {0.0055, 32, 1024, 1.0, 1.0, GenPhilox, 1234ULL},
-  {0.011, 8, 1024, 1.0, 1.0, GenPhilox, 1234ULL},
-  {0.0055, 32, 1024, 1.0, 1.0, GenTaps, 1234ULL},
-  {0.011, 8, 1024, 1.0, 1.0, GenTaps, 1234ULL},
-  {0.0055, 32, 1024, 1.0, 1.0, GenKiss99, 1234ULL},
-  {0.011, 8, 1024, 1.0, 1.0, GenKiss99, 1234ULL}};
-TEST_P(RngNormalTableTestD, Result) {
-  double meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(match(meanvar[0], h_stats[0],
-                    CompareApprox<double>(num_sigma * params.tolerance)));
-  ASSERT_TRUE(match(meanvar[1], h_stats[1],
-                    CompareApprox<double>(num_sigma * params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngNormalTableTests, RngNormalTableTestD,
-                        ::testing::ValuesIn(inputsd_t));
-
-struct RngAffineInputs {
-  int n;
-  unsigned long long seed;
-};
-
-class RngAffineTest : public ::testing::TestWithParam<RngAffineInputs> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<RngAffineInputs>::GetParam();
-    Rng r(params.seed);
-    r.affine_transform_params(params.n, a, b);
-  }
-
-  void check() {
-    ASSERT_TRUE(gcd(a, params.n) == 1);
-    ASSERT_TRUE(0 <= b && b < params.n);
-  }
-
- private:
-  RngAffineInputs params;
-  int a, b;
-};  // RngAffineTest
-
-const std::vector<RngAffineInputs> inputs_affine = {
-  {100, 123456ULL},     {100, 1234567890ULL},  {101, 123456ULL},
-  {101, 1234567890ULL}, {7, 123456ULL},        {7, 1234567890ULL},
-  {2568, 123456ULL},    {2568, 1234567890ULL},
-};
-TEST_P(RngAffineTest, Result) { check(); }
-INSTANTIATE_TEST_CASE_P(RngAffineTests, RngAffineTest,
-                        ::testing::ValuesIn(inputs_affine));
-
-}  // namespace random
-}  // namespace raft
diff --git a/cpp/test/prims/rng_int.cu b/cpp/test/prims/rng_int.cu
deleted file mode 100644
index b4e174eff1..0000000000
--- a/cpp/test/prims/rng_int.cu
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cub/cub.cuh>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace random {
-
-enum RandomType { RNG_Uniform };
-
-template <typename T, int TPB>
-__global__ void meanKernel(float *out, const T *data, int len) {
-  typedef cub::BlockReduce<float, TPB> BlockReduce;
-  __shared__ typename BlockReduce::TempStorage temp_storage;
-  int tid = threadIdx.x + blockIdx.x * blockDim.x;
-  float val = tid < len ? data[tid] : T(0);
-  float x = BlockReduce(temp_storage).Sum(val);
-  __syncthreads();
-  float xx = BlockReduce(temp_storage).Sum(val * val);
-  __syncthreads();
-  if (threadIdx.x == 0) {
-    raft::myAtomicAdd(out, x);
-    raft::myAtomicAdd(out + 1, xx);
-  }
-}
-
-template <typename T>
-struct RngInputs {
-  float tolerance;
-  int len;
-  // start, end: for uniform
-  // mean, sigma: for normal/lognormal
-  // mean, beta: for gumbel
-  // mean, scale: for logistic and laplace
-  // lambda: for exponential
-  // sigma: for rayleigh
-  T start, end;
-  RandomType type;
-  GeneratorType gtype;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const RngInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class RngTest : public ::testing::TestWithParam<RngInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<RngInputs<T>>::GetParam();
-    Rng r(params.seed, params.gtype);
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    allocate(data, params.len);
-    allocate(stats, 2, true);
-    switch (params.type) {
-      case RNG_Uniform:
-        r.uniformInt(data, params.len, params.start, params.end, stream);
-        break;
-    };
-    static const int threads = 128;
-    meanKernel<T, threads>
-      <<<raft::ceildiv(params.len, threads), threads, 0, stream>>>(stats, data,
-                                                                   params.len);
-    update_host<float>(h_stats, stats, 2, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    h_stats[0] /= params.len;
-    h_stats[1] = (h_stats[1] / params.len) - (h_stats[0] * h_stats[0]);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(stats));
-  }
-
-  void getExpectedMeanVar(float meanvar[2]) {
-    switch (params.type) {
-      case RNG_Uniform:
-        meanvar[0] = (params.start + params.end) * 0.5f;
-        meanvar[1] = params.end - params.start;
-        meanvar[1] = meanvar[1] * meanvar[1] / 12.f;
-        break;
-    };
-  }
-
- protected:
-  RngInputs<T> params;
-  T *data;
-  float *stats;
-  float h_stats[2];  // mean, var
-};
-
-typedef RngTest<uint32_t> RngTestU32;
-const std::vector<RngInputs<uint32_t>> inputs_u32 = {
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL}};
-TEST_P(RngTestU32, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(
-    match(meanvar[0], h_stats[0], CompareApprox<float>(params.tolerance)));
-  ASSERT_TRUE(
-    match(meanvar[1], h_stats[1], CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestU32, ::testing::ValuesIn(inputs_u32));
-
-typedef RngTest<uint64_t> RngTestU64;
-const std::vector<RngInputs<uint64_t>> inputs_u64 = {
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL}};
-TEST_P(RngTestU64, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(
-    match(meanvar[0], h_stats[0], CompareApprox<float>(params.tolerance)));
-  ASSERT_TRUE(
-    match(meanvar[1], h_stats[1], CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestU64, ::testing::ValuesIn(inputs_u64));
-
-typedef RngTest<int32_t> RngTestS32;
-const std::vector<RngInputs<int32_t>> inputs_s32 = {
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL}};
-TEST_P(RngTestS32, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(
-    match(meanvar[0], h_stats[0], CompareApprox<float>(params.tolerance)));
-  ASSERT_TRUE(
-    match(meanvar[1], h_stats[1], CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestS32, ::testing::ValuesIn(inputs_s32));
-
-typedef RngTest<int64_t> RngTestS64;
-const std::vector<RngInputs<int64_t>> inputs_s64 = {
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenPhilox, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenTaps, 1234ULL},
-  {0.1f, 32 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL},
-  {0.1f, 8 * 1024, 0, 20, RNG_Uniform, GenKiss99, 1234ULL}};
-TEST_P(RngTestS64, Result) {
-  float meanvar[2];
-  getExpectedMeanVar(meanvar);
-  ASSERT_TRUE(
-    match(meanvar[0], h_stats[0], CompareApprox<float>(params.tolerance)));
-  ASSERT_TRUE(
-    match(meanvar[1], h_stats[1], CompareApprox<float>(params.tolerance)));
-}
-INSTANTIATE_TEST_CASE_P(RngTests, RngTestS64, ::testing::ValuesIn(inputs_s64));
-
-}  // namespace random
-}  // namespace raft
diff --git a/cpp/test/prims/rsvd.cu b/cpp/test/prims/rsvd.cu
index 082647f34a..07d3315521 100644
--- a/cpp/test/prims/rsvd.cu
+++ b/cpp/test/prims/rsvd.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <linalg/rsvd.cuh>
+#include <raft/cuda_utils.cuh>
 #include <raft/handle.hpp>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/sample_without_replacement.cu b/cpp/test/prims/sample_without_replacement.cu
deleted file mode 100644
index 7aea05ccbe..0000000000
--- a/cpp/test/prims/sample_without_replacement.cu
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include <set>
-#include <vector>
-#include "test_utils.h"
-
-namespace raft {
-namespace random {
-
-// Terminology:
-// SWoR - Sample Without Replacement
-
-template <typename T>
-struct SWoRInputs {
-  int len, sampledLen;
-  int largeWeightIndex;
-  T largeWeight;
-  GeneratorType gtype;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream& operator<<(::std::ostream& os, const SWoRInputs<T>& dims) {
-  return os;
-}
-
-template <typename T>
-class SWoRTest : public ::testing::TestWithParam<SWoRInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<SWoRInputs<T>>::GetParam();
-    CUDA_CHECK(cudaStreamCreate(&stream));
-
-    Rng r(params.seed, params.gtype);
-    allocate(in, params.len);
-    allocate(wts, params.len);
-    allocate(out, params.sampledLen);
-    allocate(outIdx, params.sampledLen);
-    h_outIdx.resize(params.sampledLen);
-    r.uniform(in, params.len, T(-1.0), T(1.0), stream);
-    r.uniform(wts, params.len, T(1.0), T(2.0), stream);
-    if (params.largeWeightIndex >= 0) {
-      update_device(wts + params.largeWeightIndex, &params.largeWeight, 1,
-                    stream);
-    }
-    r.sampleWithoutReplacement(handle, out, outIdx, in, wts, params.sampledLen,
-                               params.len, stream);
-    update_host(&(h_outIdx[0]), outIdx, params.sampledLen, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(wts));
-    CUDA_CHECK(cudaFree(out));
-    CUDA_CHECK(cudaFree(outIdx));
-  }
-
- protected:
-  SWoRInputs<T> params;
-  T *in, *out, *wts;
-  int* outIdx;
-  std::vector<int> h_outIdx;
-  cudaStream_t stream;
-  raft::handle_t handle;
-};
-
-typedef SWoRTest<float> SWoRTestF;
-const std::vector<SWoRInputs<float>> inputsf = {
-  {1024, 512, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 1024, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 512 + 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 1024 - 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 512 + 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 1024 - 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 512, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 1024, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 512, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 1024, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.f, GenPhilox, 1234ULL},
-  {1024, 512, 10, 100000.f, GenPhilox, 1234ULL},
-
-  {1024, 512, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 1024, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 512 + 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 1024 - 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 512 + 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 1024 - 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 512, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 1024, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 512, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 1024, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.f, GenTaps, 1234ULL},
-  {1024, 512, 10, 100000.f, GenTaps, 1234ULL},
-
-  {1024, 512, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 1024, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 512 + 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 1024 - 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 512 + 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 1024 - 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 512, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 1024, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 512, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 1024, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.f, GenKiss99, 1234ULL},
-  {1024, 512, 10, 100000.f, GenKiss99, 1234ULL},
-};
-
-TEST_P(SWoRTestF, Result) {
-  std::set<int> occurence;
-  for (int i = 0; i < params.sampledLen; ++i) {
-    auto val = h_outIdx[i];
-    // indices must be in the given range
-    ASSERT_TRUE(0 <= val && val < params.len)
-      << "out-of-range index @i=" << i << " val=" << val
-      << " sampledLen=" << params.sampledLen;
-    // indices should not repeat
-    ASSERT_TRUE(occurence.find(val) == occurence.end())
-      << "repeated index @i=" << i << " idx=" << val;
-    occurence.insert(val);
-  }
-  // if there's a skewed distribution, the top index should correspond to the
-  // particular item with a large weight
-  if (params.largeWeightIndex >= 0) {
-    ASSERT_EQ(h_outIdx[0], params.largeWeightIndex);
-  }
-}
-INSTANTIATE_TEST_CASE_P(SWoRTests, SWoRTestF, ::testing::ValuesIn(inputsf));
-
-typedef SWoRTest<double> SWoRTestD;
-const std::vector<SWoRInputs<double>> inputsd = {
-  {1024, 512, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 1024, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 512 + 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 1024 - 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 512 + 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 1024 - 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 512, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 1024, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 512, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 1024, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.0, GenPhilox, 1234ULL},
-  {1024, 512, 10, 100000.0, GenPhilox, 1234ULL},
-
-  {1024, 512, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 1024, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 512 + 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 1024 - 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 512 + 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 1024 - 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 512, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 1024, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 512, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 1024, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.0, GenTaps, 1234ULL},
-  {1024, 512, 10, 100000.0, GenTaps, 1234ULL},
-
-  {1024, 512, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 1024, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 512 + 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 1024 - 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 512 + 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 1024 - 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 512, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 1024, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 512 + 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 1024 + 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 512 + 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 1, 1024 - 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 512, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 1024, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 512 + 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 1024 + 1, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 512 + 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024 + 2, 1024 + 2, -1, 0.0, GenKiss99, 1234ULL},
-  {1024, 512, 10, 100000.0, GenKiss99, 1234ULL},
-};
-
-TEST_P(SWoRTestD, Result) {
-  std::set<int> occurence;
-  for (int i = 0; i < params.sampledLen; ++i) {
-    auto val = h_outIdx[i];
-    // indices must be in the given range
-    ASSERT_TRUE(0 <= val && val < params.len)
-      << "out-of-range index @i=" << i << " val=" << val
-      << " sampledLen=" << params.sampledLen;
-    // indices should not repeat
-    ASSERT_TRUE(occurence.find(val) == occurence.end())
-      << "repeated index @i=" << i << " idx=" << val;
-    occurence.insert(val);
-  }
-  // if there's a skewed distribution, the top index should correspond to the
-  // particular item with a large weight
-  if (params.largeWeightIndex >= 0) {
-    ASSERT_EQ(h_outIdx[0], params.largeWeightIndex);
-  }
-}
-INSTANTIATE_TEST_CASE_P(SWoRTests, SWoRTestD, ::testing::ValuesIn(inputsd));
-
-}  // namespace random
-}  // namespace raft
diff --git a/cpp/test/prims/scatter.cu b/cpp/test/prims/scatter.cu
deleted file mode 100644
index e774299755..0000000000
--- a/cpp/test/prims/scatter.cu
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2019-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <algorithm>
-#include <common/scatter.cuh>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include <random>
-#include "test_utils.h"
-
-namespace MLCommon {
-
-template <typename DataT, typename IdxT>
-__global__ void naiveScatterKernel(DataT *out, const DataT *in, const IdxT *idx,
-                                   IdxT len) {
-  IdxT tid = threadIdx.x + blockIdx.x * blockDim.x;
-  if (tid < len) {
-    out[tid] = in[idx[tid]];
-  }
-}
-
-template <typename DataT, typename IdxT>
-void naiveScatter(DataT *out, const DataT *in, const IdxT *idx, IdxT len,
-                  cudaStream_t stream) {
-  int nblks = raft::ceildiv<int>(len, 128);
-  naiveScatterKernel<DataT, IdxT><<<nblks, 128, 0, stream>>>(out, in, idx, len);
-}
-
-struct ScatterInputs {
-  int len;
-  unsigned long long int seed;
-};
-
-template <typename DataT>
-class ScatterTest : public ::testing::TestWithParam<ScatterInputs> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<ScatterInputs>::GetParam();
-    raft::random::Rng r(params.seed);
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    int len = params.len;
-    raft::allocate(in, len);
-    raft::allocate(ref_out, len);
-    raft::allocate(out, len);
-    raft::allocate(idx, len);
-    r.uniform(in, len, DataT(-1.0), DataT(1.0), stream);
-    {
-      std::vector<int> h_idx(len, 0);
-      for (int i = 0; i < len; ++i) {
-        h_idx[i] = i;
-      }
-      std::random_device rd;
-      std::mt19937 g(rd());
-      std::shuffle(h_idx.begin(), h_idx.end(), g);
-      raft::update_device(idx, &(h_idx[0]), len, stream);
-      CUDA_CHECK(cudaStreamSynchronize(stream));
-    }
-    naiveScatter(ref_out, in, idx, len, stream);
-    raft::scatter(out, in, idx, len, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(ref_out));
-    CUDA_CHECK(cudaFree(out));
-    CUDA_CHECK(cudaFree(idx));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
- protected:
-  cudaStream_t stream;
-  ScatterInputs params;
-  DataT *in, *ref_out, *out;
-  int *idx;
-};
-
-const std::vector<ScatterInputs> inputs = {
-  {128, 1234ULL}, {129, 1234ULL}, {130, 1234ULL}};
-
-typedef ScatterTest<float> ScatterTestF;
-TEST_P(ScatterTestF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(out, ref_out, params.len, raft::Compare<float>()));
-}
-INSTANTIATE_TEST_CASE_P(ScatterTests, ScatterTestF,
-                        ::testing::ValuesIn(inputs));
-
-typedef ScatterTest<double> ScatterTestD;
-TEST_P(ScatterTestD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(out, ref_out, params.len, raft::Compare<double>()));
-}
-INSTANTIATE_TEST_CASE_P(ScatterTests, ScatterTestD,
-                        ::testing::ValuesIn(inputs));
-
-}  // end namespace MLCommon
diff --git a/cpp/test/prims/score.cu b/cpp/test/prims/score.cu
index 4414e8de5a..e0c3b3ffd5 100644
--- a/cpp/test/prims/score.cu
+++ b/cpp/test/prims/score.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <iostream>
 #include <metrics/scores.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include <vector>
 #include "test_utils.h"
 
diff --git a/cpp/test/prims/sigmoid.cu b/cpp/test/prims/sigmoid.cu
index 119894fea7..a6df3e4322 100644
--- a/cpp/test/prims/sigmoid.cu
+++ b/cpp/test/prims/sigmoid.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <functions/sigmoid.cuh>
+#include <raft/cuda_utils.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/silhouetteScore.cu b/cpp/test/prims/silhouetteScore.cu
index 69f56691d0..1292c68bd4 100644
--- a/cpp/test/prims/silhouetteScore.cu
+++ b/cpp/test/prims/silhouetteScore.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/sqrt.cu b/cpp/test/prims/sqrt.cu
index 6f4dd394af..11a6ad716c 100644
--- a/cpp/test/prims/sqrt.cu
+++ b/cpp/test/prims/sqrt.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <linalg/sqrt.cuh>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
diff --git a/cpp/test/prims/stddev.cu b/cpp/test/prims/stddev.cu
deleted file mode 100644
index 4d597b0891..0000000000
--- a/cpp/test/prims/stddev.cu
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <matrix/math.cuh>
-#include <random/rng.cuh>
-#include <stats/mean.cuh>
-#include <stats/stddev.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace stats {
-
-template <typename T>
-struct StdDevInputs {
-  T tolerance, mean, stddev;
-  int rows, cols;
-  bool sample, rowMajor;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const StdDevInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class StdDevTest : public ::testing::TestWithParam<StdDevInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<StdDevInputs<T>>::GetParam();
-    random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    allocate(data, len);
-    allocate(mean_act, cols);
-    allocate(stddev_act, cols);
-    allocate(vars_act, cols);
-    r.normal(data, len, params.mean, params.stddev, stream);
-    stdVarSGtest(data, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void stdVarSGtest(T *data, cudaStream_t stream) {
-    int rows = params.rows, cols = params.cols;
-
-    mean(mean_act, data, cols, rows, params.sample, params.rowMajor, stream);
-
-    stddev(stddev_act, data, mean_act, cols, rows, params.sample,
-           params.rowMajor, stream);
-
-    vars(vars_act, data, mean_act, cols, rows, params.sample, params.rowMajor,
-         stream);
-
-    raft::matrix::seqRoot(vars_act, T(1), cols, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(mean_act));
-    CUDA_CHECK(cudaFree(stddev_act));
-    CUDA_CHECK(cudaFree(vars_act));
-  }
-
- protected:
-  StdDevInputs<T> params;
-  T *data, *mean_act, *stddev_act, *vars_act;
-};
-
-const std::vector<StdDevInputs<float>> inputsf = {
-  {0.1f, 1.f, 2.f, 1024, 32, true, false, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 64, true, false, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 128, true, false, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 256, true, false, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 32, false, false, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 64, false, false, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 128, false, false, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 256, false, false, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 32, true, true, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 64, true, true, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 128, true, true, 1234ULL},
-  {0.1f, 1.f, 2.f, 1024, 256, true, true, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 32, false, true, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 64, false, true, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 128, false, true, 1234ULL},
-  {0.1f, -1.f, 2.f, 1024, 256, false, true, 1234ULL}};
-
-const std::vector<StdDevInputs<double>> inputsd = {
-  {0.1, 1.0, 2.0, 1024, 32, true, false, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 64, true, false, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 128, true, false, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 256, true, false, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 32, false, false, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 64, false, false, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 128, false, false, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 256, false, false, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 32, true, true, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 64, true, true, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 128, true, true, 1234ULL},
-  {0.1, 1.0, 2.0, 1024, 256, true, true, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 32, false, true, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 64, false, true, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 128, false, true, 1234ULL},
-  {0.1, -1.0, 2.0, 1024, 256, false, true, 1234ULL}};
-
-typedef StdDevTest<float> StdDevTestF;
-TEST_P(StdDevTestF, Result) {
-  ASSERT_TRUE(devArrMatch(params.stddev, stddev_act, params.cols,
-                          CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(devArrMatch(stddev_act, vars_act, params.cols,
-                          CompareApprox<float>(params.tolerance)));
-}
-
-typedef StdDevTest<double> StdDevTestD;
-TEST_P(StdDevTestD, Result) {
-  ASSERT_TRUE(devArrMatch(params.stddev, stddev_act, params.cols,
-                          CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(devArrMatch(stddev_act, vars_act, params.cols,
-                          CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(StdDevTests, StdDevTestF, ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(StdDevTests, StdDevTestD, ::testing::ValuesIn(inputsd));
-
-}  // end namespace stats
-}  // end namespace raft
diff --git a/cpp/test/prims/strided_reduction.cu b/cpp/test/prims/strided_reduction.cu
deleted file mode 100644
index ee223ca09e..0000000000
--- a/cpp/test/prims/strided_reduction.cu
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/strided_reduction.cuh>
-#include <random/rng.cuh>
-#include "reduce.cuh"
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct stridedReductionInputs {
-  T tolerance;
-  int rows, cols;
-  unsigned long long int seed;
-};
-
-template <typename T>
-void stridedReductionLaunch(T *dots, const T *data, int cols, int rows,
-                            cudaStream_t stream) {
-  stridedReduction(dots, data, cols, rows, (T)0, stream, false,
-                   [] __device__(T in, int i) { return in * in; });
-}
-
-template <typename T>
-class stridedReductionTest
-  : public ::testing::TestWithParam<stridedReductionInputs<T>> {
- protected:
-  void SetUp() override {
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    params = ::testing::TestWithParam<stridedReductionInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-
-    raft::allocate(data, len);
-    raft::allocate(dots_exp, cols);  //expected dot products (from test)
-    raft::allocate(dots_act, cols);  //actual dot products (from prim)
-    r.uniform(data, len, T(-1.0), T(1.0),
-              stream);  //initialize matrix to random
-
-    unaryAndGemv(dots_exp, data, cols, rows, stream);
-    stridedReductionLaunch(dots_act, data, cols, rows, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(dots_exp));
-    CUDA_CHECK(cudaFree(dots_act));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
- protected:
-  stridedReductionInputs<T> params;
-  T *data, *dots_exp, *dots_act;
-  cudaStream_t stream;
-};
-
-const std::vector<stridedReductionInputs<float>> inputsf = {
-  {0.00001f, 1024, 32, 1234ULL},
-  {0.00001f, 1024, 64, 1234ULL},
-  {0.00001f, 1024, 128, 1234ULL},
-  {0.00001f, 1024, 256, 1234ULL}};
-
-const std::vector<stridedReductionInputs<double>> inputsd = {
-  {0.000000001, 1024, 32, 1234ULL},
-  {0.000000001, 1024, 64, 1234ULL},
-  {0.000000001, 1024, 128, 1234ULL},
-  {0.000000001, 1024, 256, 1234ULL}};
-
-typedef stridedReductionTest<float> stridedReductionTestF;
-TEST_P(stridedReductionTestF, Result) {
-  ASSERT_TRUE(devArrMatch(dots_exp, dots_act, params.cols,
-                          raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef stridedReductionTest<double> stridedReductionTestD;
-TEST_P(stridedReductionTestD, Result) {
-  ASSERT_TRUE(devArrMatch(dots_exp, dots_act, params.cols,
-                          raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(stridedReductionTests, stridedReductionTestF,
-                        ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(stridedReductionTests, stridedReductionTestD,
-                        ::testing::ValuesIn(inputsd));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/subtract.cu b/cpp/test/prims/subtract.cu
deleted file mode 100644
index 2468eb0f0b..0000000000
--- a/cpp/test/prims/subtract.cu
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/subtract.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename Type>
-__global__ void naiveSubtractElemKernel(Type *out, const Type *in1,
-                                        const Type *in2, int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = in1[idx] - in2[idx];
-  }
-}
-
-template <typename Type>
-void naiveSubtractElem(Type *out, const Type *in1, const Type *in2, int len,
-                       cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveSubtractElemKernel<Type><<<nblks, TPB, 0, stream>>>(out, in1, in2, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename Type>
-__global__ void naiveSubtractScalarKernel(Type *out, const Type *in1,
-                                          const Type in2, int len) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  if (idx < len) {
-    out[idx] = in1[idx] - in2;
-  }
-}
-
-template <typename Type>
-void naiveSubtractScalar(Type *out, const Type *in1, const Type in2, int len,
-                         cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveSubtractScalarKernel<Type>
-    <<<nblks, TPB, 0, stream>>>(out, in1, in2, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename T>
-struct SubtractInputs {
-  T tolerance;
-  int len;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const SubtractInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class SubtractTest : public ::testing::TestWithParam<SubtractInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<SubtractInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(in1, len);
-    raft::allocate(in2, len);
-    raft::allocate(out_ref, len);
-    raft::allocate(out, len);
-    r.uniform(in1, len, T(-1.0), T(1.0), stream);
-    r.uniform(in2, len, T(-1.0), T(1.0), stream);
-
-    naiveSubtractElem(out_ref, in1, in2, len, stream);
-    naiveSubtractScalar(out_ref, out_ref, T(1), len, stream);
-
-    subtract(out, in1, in2, len, stream);
-    subtractScalar(out, out, T(1), len, stream);
-    subtract(in1, in1, in2, len, stream);
-    subtractScalar(in1, in1, T(1), len, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(in1));
-    CUDA_CHECK(cudaFree(in2));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
- protected:
-  SubtractInputs<T> params;
-  T *in1, *in2, *out_ref, *out;
-};
-
-const std::vector<SubtractInputs<float>> inputsf2 = {
-  {0.000001f, 1024 * 1024, 1234ULL}};
-
-const std::vector<SubtractInputs<double>> inputsd2 = {
-  {0.00000001, 1024 * 1024, 1234ULL}};
-
-typedef SubtractTest<float> SubtractTestF;
-TEST_P(SubtractTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(out_ref, out, params.len,
-                                raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_ref, in1, params.len,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef SubtractTest<double> SubtractTestD;
-TEST_P(SubtractTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(out_ref, out, params.len,
-                                raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_ref, in1, params.len,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(SubtractTests, SubtractTestF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(SubtractTests, SubtractTestD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/sum.cu b/cpp/test/prims/sum.cu
deleted file mode 100644
index 995c4dffd7..0000000000
--- a/cpp/test/prims/sum.cu
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/eltwise.cuh>
-#include <random/rng.cuh>
-#include <stats/sum.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace stats {
-
-template <typename T>
-struct SumInputs {
-  T tolerance;
-  int rows, cols;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const SumInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class SumTest : public ::testing::TestWithParam<SumInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<SumInputs<T>>::GetParam();
-    int rows = params.rows, cols = params.cols;
-    int len = rows * cols;
-    cudaStream_t stream;
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    raft::allocate(data, len);
-
-    T data_h[len];
-    for (int i = 0; i < len; i++) {
-      data_h[i] = T(1);
-    }
-
-    raft::update_device(data, data_h, len, stream);
-
-    raft::allocate(sum_act, cols);
-    sum(sum_act, data, cols, rows, false, stream);
-    CUDA_CHECK(cudaStreamDestroy(stream));
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(sum_act));
-  }
-
- protected:
-  SumInputs<T> params;
-  T *data, *sum_act;
-};
-
-const std::vector<SumInputs<float>> inputsf = {{0.05f, 1024, 32, 1234ULL},
-                                               {0.05f, 1024, 256, 1234ULL}};
-
-const std::vector<SumInputs<double>> inputsd = {{0.05, 1024, 32, 1234ULL},
-                                                {0.05, 1024, 256, 1234ULL}};
-
-typedef SumTest<float> SumTestF;
-TEST_P(SumTestF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(float(params.rows), sum_act, params.cols,
-                                raft::CompareApprox<float>(params.tolerance)));
-}
-
-typedef SumTest<double> SumTestD;
-TEST_P(SumTestD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(double(params.rows), sum_act, params.cols,
-                                raft::CompareApprox<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(SumTests, SumTestF, ::testing::ValuesIn(inputsf));
-
-INSTANTIATE_TEST_CASE_P(SumTests, SumTestD, ::testing::ValuesIn(inputsd));
-
-}  // end namespace stats
-}  // end namespace raft
diff --git a/cpp/test/prims/svd.cu b/cpp/test/prims/svd.cu
deleted file mode 100644
index 86d725ad4a..0000000000
--- a/cpp/test/prims/svd.cu
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <cuda_utils.cuh>
-#include <linalg/svd.cuh>
-#include <matrix/matrix.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct SvdInputs {
-  T tolerance;
-  int len;
-  int n_row;
-  int n_col;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const SvdInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class SvdTest : public ::testing::TestWithParam<SvdInputs<T>> {
- protected:
-  void SetUp() override {
-    raft::handle_t handle;
-
-    params = ::testing::TestWithParam<SvdInputs<T>>::GetParam();
-    raft::random::Rng r(params.seed);
-    int len = params.len;
-    cudaStream_t stream = handle.get_stream();
-    raft::allocate(data, len);
-
-    ASSERT(params.n_row == 3, "This test only supports nrows=3!");
-    ASSERT(params.len == 6, "This test only supports len=6!");
-    T data_h[] = {1.0, 4.0, 2.0, 2.0, 5.0, 1.0};
-    raft::update_device(data, data_h, len, stream);
-
-    int left_evl = params.n_row * params.n_col;
-    int right_evl = params.n_col * params.n_col;
-
-    raft::allocate(left_eig_vectors_qr, left_evl);
-    raft::allocate(right_eig_vectors_trans_qr, right_evl);
-    raft::allocate(sing_vals_qr, params.n_col);
-
-    // allocate(left_eig_vectors_jacobi, left_evl);
-    // allocate(right_eig_vectors_trans_jacobi, right_evl);
-    // allocate(sing_vals_jacobi, params.n_col);
-
-    T left_eig_vectors_ref_h[] = {-0.308219, -0.906133, -0.289695,
-                                  0.488195,  0.110706,  -0.865685};
-
-    T right_eig_vectors_ref_h[] = {-0.638636, -0.769509, -0.769509, 0.638636};
-
-    T sing_vals_ref_h[] = {7.065283, 1.040081};
-
-    raft::allocate(left_eig_vectors_ref, left_evl);
-    raft::allocate(right_eig_vectors_ref, right_evl);
-    raft::allocate(sing_vals_ref, params.n_col);
-
-    raft::update_device(left_eig_vectors_ref, left_eig_vectors_ref_h, left_evl,
-                        stream);
-    raft::update_device(right_eig_vectors_ref, right_eig_vectors_ref_h,
-                        right_evl, stream);
-    raft::update_device(sing_vals_ref, sing_vals_ref_h, params.n_col, stream);
-
-    svdQR(handle, data, params.n_row, params.n_col, sing_vals_qr,
-          left_eig_vectors_qr, right_eig_vectors_trans_qr, true, true, true,
-          stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(left_eig_vectors_qr));
-    CUDA_CHECK(cudaFree(right_eig_vectors_trans_qr));
-    CUDA_CHECK(cudaFree(sing_vals_qr));
-    CUDA_CHECK(cudaFree(left_eig_vectors_ref));
-    CUDA_CHECK(cudaFree(right_eig_vectors_ref));
-    CUDA_CHECK(cudaFree(sing_vals_ref));
-  }
-
- protected:
-  SvdInputs<T> params;
-  T *data, *left_eig_vectors_qr, *right_eig_vectors_trans_qr, *sing_vals_qr,
-    *left_eig_vectors_ref, *right_eig_vectors_ref, *sing_vals_ref;
-};
-
-const std::vector<SvdInputs<float>> inputsf2 = {
-  {0.00001f, 3 * 2, 3, 2, 1234ULL}};
-
-const std::vector<SvdInputs<double>> inputsd2 = {
-  {0.00001, 3 * 2, 3, 2, 1234ULL}};
-
-typedef SvdTest<float> SvdTestValF;
-TEST_P(SvdTestValF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(sing_vals_ref, sing_vals_qr, params.n_col,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef SvdTest<double> SvdTestValD;
-TEST_P(SvdTestValD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(sing_vals_ref, sing_vals_qr, params.n_col,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef SvdTest<float> SvdTestLeftVecF;
-TEST_P(SvdTestLeftVecF, Result) {
-  ASSERT_TRUE(raft::devArrMatch(
-    left_eig_vectors_ref, left_eig_vectors_qr, params.n_row * params.n_col,
-    raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef SvdTest<double> SvdTestLeftVecD;
-TEST_P(SvdTestLeftVecD, Result) {
-  ASSERT_TRUE(raft::devArrMatch(
-    left_eig_vectors_ref, left_eig_vectors_qr, params.n_row * params.n_col,
-    raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-typedef SvdTest<float> SvdTestRightVecF;
-TEST_P(SvdTestRightVecF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(right_eig_vectors_ref, right_eig_vectors_trans_qr,
-                      params.n_col * params.n_col,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef SvdTest<double> SvdTestRightVecD;
-TEST_P(SvdTestRightVecD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(right_eig_vectors_ref, right_eig_vectors_trans_qr,
-                      params.n_col * params.n_col,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestValF, ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestValD, ::testing::ValuesIn(inputsd2));
-
-INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestLeftVecF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestLeftVecD,
-                        ::testing::ValuesIn(inputsd2));
-
-// INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestRightVecF,
-// ::testing::ValuesIn(inputsf2));
-
-// INSTANTIATE_TEST_CASE_P(SvdTests, SvdTestRightVecD,
-//::testing::ValuesIn(inputsd2));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/ternary_op.cu b/cpp/test/prims/ternary_op.cu
index 9065562fad..78b32b2406 100644
--- a/cpp/test/prims/ternary_op.cu
+++ b/cpp/test/prims/ternary_op.cu
@@ -14,23 +14,33 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <linalg/ternary_op.cuh>
-#include <random/rng.cuh>
-#include "binary_op.cuh"
+#include <raft/random/rng.cuh>
 #include "test_utils.h"
 
 namespace MLCommon {
 namespace LinAlg {
 
+template <typename InType, typename IdxType = int, typename OutType = InType>
+struct BinaryOpInputs {
+  InType tolerance;
+  IdxType len;
+  unsigned long long int seed;
+};
+
+template <typename InType, typename IdxType = int, typename OutType = InType>
+::std::ostream &operator<<(::std::ostream &os,
+                           const BinaryOpInputs<InType, IdxType, OutType> &d) {
+  return os;
+}
+
 template <typename T>
-class ternaryOpTest
-  : public ::testing::TestWithParam<raft::linalg::BinaryOpInputs<T>> {
+class ternaryOpTest : public ::testing::TestWithParam<BinaryOpInputs<T>> {
  public:
   void SetUp() override {
-    params =
-      ::testing::TestWithParam<raft::linalg::BinaryOpInputs<T>>::GetParam();
+    params = ::testing::TestWithParam<BinaryOpInputs<T>>::GetParam();
     raft::random::Rng rng(params.seed);
 
     int len = params.len;
@@ -68,11 +78,11 @@ class ternaryOpTest
   }
 
  protected:
-  raft::linalg::BinaryOpInputs<T> params;
+  BinaryOpInputs<T> params;
   T *in1, *in2, *in3, *out_add_ref, *out_mul_ref, *out_add, *out_mul;
 };
 
-const std::vector<raft::linalg::BinaryOpInputs<float>> inputsf = {
+const std::vector<BinaryOpInputs<float>> inputsf = {
   {0.000001f, 1024 * 1024, 1234ULL},
   {0.000001f, 1024 * 1024 + 2, 1234ULL},
   {0.000001f, 1024 * 1024 + 1, 1234ULL}};
@@ -86,7 +96,7 @@ TEST_P(ternaryOpTestF, Result) {
 INSTANTIATE_TEST_CASE_P(ternaryOpTests, ternaryOpTestF,
                         ::testing::ValuesIn(inputsf));
 
-const std::vector<raft::linalg::BinaryOpInputs<double>> inputsd = {
+const std::vector<BinaryOpInputs<double>> inputsd = {
   {0.00000001, 1024 * 1024, 1234ULL},
   {0.00000001, 1024 * 1024 + 2, 1234ULL},
   {0.00000001, 1024 * 1024 + 1, 1234ULL}};
diff --git a/cpp/test/prims/test_utils.h b/cpp/test/prims/test_utils.h
index fa668f7da9..1629e8aa34 100644
--- a/cpp/test/prims/test_utils.h
+++ b/cpp/test/prims/test_utils.h
@@ -15,11 +15,11 @@
  */
 
 #pragma once
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <iostream>
 #include <memory>
+#include <raft/cuda_utils.cuh>
 
 namespace raft {
 
diff --git a/cpp/test/prims/transpose.cu b/cpp/test/prims/transpose.cu
deleted file mode 100644
index dbc66f0f84..0000000000
--- a/cpp/test/prims/transpose.cu
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/transpose.h>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename T>
-struct TranposeInputs {
-  T tolerance;
-  int len;
-  int n_row;
-  int n_col;
-  unsigned long long int seed;
-};
-
-template <typename T>
-::std::ostream &operator<<(::std::ostream &os, const TranposeInputs<T> &dims) {
-  return os;
-}
-
-template <typename T>
-class TransposeTest : public ::testing::TestWithParam<TranposeInputs<T>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<TranposeInputs<T>>::GetParam();
-
-    stream = handle.get_stream();
-
-    int len = params.len;
-
-    raft::allocate(data, len);
-    ASSERT(params.len == 9, "This test works only with len=9!");
-    T data_h[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
-    raft::update_device(data, data_h, len, stream);
-
-    raft::allocate(data_trans_ref, len);
-    T data_ref_h[] = {1.0, 4.0, 7.0, 2.0, 5.0, 8.0, 3.0, 6.0, 9.0};
-    raft::update_device(data_trans_ref, data_ref_h, len, stream);
-
-    raft::allocate(data_trans, len);
-
-    transpose(handle, data, data_trans, params.n_row, params.n_col, stream);
-    transpose(data, params.n_row, stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaFree(data));
-    CUDA_CHECK(cudaFree(data_trans));
-    CUDA_CHECK(cudaFree(data_trans_ref));
-  }
-
- protected:
-  TranposeInputs<T> params;
-  T *data, *data_trans, *data_trans_ref;
-  raft::handle_t handle;
-  cudaStream_t stream;
-};
-
-const std::vector<TranposeInputs<float>> inputsf2 = {
-  {0.1f, 3 * 3, 3, 3, 1234ULL}};
-
-const std::vector<TranposeInputs<double>> inputsd2 = {
-  {0.1, 3 * 3, 3, 3, 1234ULL}};
-
-typedef TransposeTest<float> TransposeTestValF;
-TEST_P(TransposeTestValF, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(data_trans_ref, data_trans, params.len,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-
-  ASSERT_TRUE(
-    raft::devArrMatch(data_trans_ref, data, params.len,
-                      raft::CompareApproxAbs<float>(params.tolerance)));
-}
-
-typedef TransposeTest<double> TransposeTestValD;
-TEST_P(TransposeTestValD, Result) {
-  ASSERT_TRUE(
-    raft::devArrMatch(data_trans_ref, data_trans, params.len,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-
-  ASSERT_TRUE(
-    raft::devArrMatch(data_trans_ref, data, params.len,
-                      raft::CompareApproxAbs<double>(params.tolerance)));
-}
-
-INSTANTIATE_TEST_CASE_P(TransposeTests, TransposeTestValF,
-                        ::testing::ValuesIn(inputsf2));
-
-INSTANTIATE_TEST_CASE_P(TransposeTests, TransposeTestValD,
-                        ::testing::ValuesIn(inputsd2));
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/trustworthiness.cu b/cpp/test/prims/trustworthiness.cu
index 3308b4cdf2..a8bf343dae 100644
--- a/cpp/test/prims/trustworthiness.cu
+++ b/cpp/test/prims/trustworthiness.cu
@@ -14,9 +14,8 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <distance/distance.cuh>
 #include <iostream>
 #include <metrics/scores.cuh>
diff --git a/cpp/test/prims/unary_op.cu b/cpp/test/prims/unary_op.cu
deleted file mode 100644
index 4ea36e71a2..0000000000
--- a/cpp/test/prims/unary_op.cu
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <common/cudart_utils.h>
-#include <gtest/gtest.h>
-#include <linalg/unary_op.cuh>
-#include <random/rng.cuh>
-#include "test_utils.h"
-#include "unary_op.cuh"
-
-namespace raft {
-namespace linalg {
-
-// Or else, we get the following compilation error
-// for an extended __device__ lambda cannot have private or protected access
-// within its class
-template <typename InType, typename IdxType = int, typename OutType = InType>
-void unaryOpLaunch(OutType *out, const InType *in, InType scalar, IdxType len,
-                   cudaStream_t stream) {
-  if (in == nullptr) {
-    auto op = [scalar] __device__(OutType * ptr, IdxType idx) {
-      *ptr = static_cast<OutType>(scalar * idx);
-    };
-    writeOnlyUnaryOp<OutType, decltype(op), IdxType>(out, len, op, stream);
-  } else {
-    auto op = [scalar] __device__(InType in) {
-      return static_cast<OutType>(in * scalar);
-    };
-    unaryOp<InType, decltype(op), IdxType, OutType>(out, in, len, op, stream);
-  }
-}
-
-template <typename InType, typename IdxType, typename OutType = InType>
-class UnaryOpTest
-  : public ::testing::TestWithParam<UnaryOpInputs<InType, IdxType, OutType>> {
- protected:
-  void SetUp() override {
-    params = ::testing::TestWithParam<
-      UnaryOpInputs<InType, IdxType, OutType>>::GetParam();
-    raft::random::Rng r(params.seed);
-    CUDA_CHECK(cudaStreamCreate(&stream));
-    auto len = params.len;
-    allocate(in, len);
-    allocate(out_ref, len);
-    allocate(out, len);
-    r.uniform(in, len, InType(-1.0), InType(1.0), stream);
-  }
-
-  void TearDown() override {
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    CUDA_CHECK(cudaStreamDestroy(stream));
-    CUDA_CHECK(cudaFree(in));
-    CUDA_CHECK(cudaFree(out_ref));
-    CUDA_CHECK(cudaFree(out));
-  }
-
-  virtual void DoTest() {
-    auto len = params.len;
-    auto scalar = params.scalar;
-    naiveScale(out_ref, in, scalar, len, stream);
-    unaryOpLaunch(out, in, scalar, len, stream);
-    CUDA_CHECK(cudaStreamSynchronize(stream));
-    ASSERT_TRUE(devArrMatch(out_ref, out, params.len,
-                            CompareApprox<OutType>(params.tolerance)));
-  }
-
-  UnaryOpInputs<InType, IdxType, OutType> params;
-  InType *in;
-  OutType *out_ref, *out;
-  cudaStream_t stream;
-};
-
-template <typename OutType, typename IdxType>
-class WriteOnlyUnaryOpTest : public UnaryOpTest<OutType, IdxType, OutType> {
- protected:
-  void DoTest() override {
-    auto len = this->params.len;
-    auto scalar = this->params.scalar;
-    naiveScale(this->out_ref, (OutType *)nullptr, scalar, len, this->stream);
-    unaryOpLaunch(this->out, (OutType *)nullptr, scalar, len, this->stream);
-    CUDA_CHECK(cudaStreamSynchronize(this->stream));
-    ASSERT_TRUE(devArrMatch(this->out_ref, this->out, this->params.len,
-                            CompareApprox<OutType>(this->params.tolerance)));
-  }
-};
-
-#define UNARY_OP_TEST(Name, inputs)  \
-  TEST_P(Name, Result) { DoTest(); } \
-  INSTANTIATE_TEST_CASE_P(UnaryOpTests, Name, ::testing::ValuesIn(inputs))
-
-const std::vector<UnaryOpInputs<float, int>> inputsf_i32 = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-typedef UnaryOpTest<float, int> UnaryOpTestF_i32;
-UNARY_OP_TEST(UnaryOpTestF_i32, inputsf_i32);
-typedef WriteOnlyUnaryOpTest<float, int> WriteOnlyUnaryOpTestF_i32;
-UNARY_OP_TEST(WriteOnlyUnaryOpTestF_i32, inputsf_i32);
-
-const std::vector<UnaryOpInputs<float, size_t>> inputsf_i64 = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-typedef UnaryOpTest<float, size_t> UnaryOpTestF_i64;
-UNARY_OP_TEST(UnaryOpTestF_i64, inputsf_i64);
-typedef WriteOnlyUnaryOpTest<float, size_t> WriteOnlyUnaryOpTestF_i64;
-UNARY_OP_TEST(WriteOnlyUnaryOpTestF_i64, inputsf_i64);
-
-const std::vector<UnaryOpInputs<float, int, double>> inputsf_i32_d = {
-  {0.000001f, 1024 * 1024, 2.f, 1234ULL}};
-typedef UnaryOpTest<float, int, double> UnaryOpTestF_i32_D;
-UNARY_OP_TEST(UnaryOpTestF_i32_D, inputsf_i32_d);
-
-const std::vector<UnaryOpInputs<double, int>> inputsd_i32 = {
-  {0.00000001, 1024 * 1024, 2.0, 1234ULL}};
-typedef UnaryOpTest<double, int> UnaryOpTestD_i32;
-UNARY_OP_TEST(UnaryOpTestD_i32, inputsd_i32);
-typedef WriteOnlyUnaryOpTest<double, int> WriteOnlyUnaryOpTestD_i32;
-UNARY_OP_TEST(WriteOnlyUnaryOpTestD_i32, inputsd_i32);
-
-const std::vector<UnaryOpInputs<double, size_t>> inputsd_i64 = {
-  {0.00000001, 1024 * 1024, 2.0, 1234ULL}};
-typedef UnaryOpTest<double, size_t> UnaryOpTestD_i64;
-UNARY_OP_TEST(UnaryOpTestD_i64, inputsd_i64);
-typedef WriteOnlyUnaryOpTest<double, size_t> WriteOnlyUnaryOpTestD_i64;
-UNARY_OP_TEST(WriteOnlyUnaryOpTestD_i64, inputsd_i64);
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/unary_op.cuh b/cpp/test/prims/unary_op.cuh
deleted file mode 100644
index 4d646ed54c..0000000000
--- a/cpp/test/prims/unary_op.cuh
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2018-2020, 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 <cuda_utils.cuh>
-#include <linalg/unary_op.cuh>
-#include "test_utils.h"
-
-namespace raft {
-namespace linalg {
-
-template <typename InType, typename OutType, typename IdxType>
-__global__ void naiveScaleKernel(OutType *out, const InType *in, InType scalar,
-                                 IdxType len) {
-  IdxType idx = threadIdx.x + ((IdxType)blockIdx.x * (IdxType)blockDim.x);
-  if (idx < len) {
-    if (in == nullptr) {
-      // used for testing writeOnlyUnaryOp
-      out[idx] = static_cast<OutType>(scalar * idx);
-    } else {
-      out[idx] = static_cast<OutType>(scalar * in[idx]);
-    }
-  }
-}
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-void naiveScale(OutType *out, const InType *in, InType scalar, int len,
-                cudaStream_t stream) {
-  static const int TPB = 64;
-  int nblks = raft::ceildiv(len, TPB);
-  naiveScaleKernel<InType, OutType, IdxType>
-    <<<nblks, TPB, 0, stream>>>(out, in, scalar, len);
-  CUDA_CHECK(cudaPeekAtLastError());
-}
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-struct UnaryOpInputs {
-  OutType tolerance;
-  IdxType len;
-  InType scalar;
-  unsigned long long int seed;
-};
-
-template <typename InType, typename IdxType = int, typename OutType = InType>
-::std::ostream &operator<<(::std::ostream &os,
-                           const UnaryOpInputs<InType, IdxType, OutType> &d) {
-  return os;
-}
-
-}  // end namespace linalg
-}  // end namespace raft
diff --git a/cpp/test/prims/vMeasure.cu b/cpp/test/prims/vMeasure.cu
index d9ca0ade02..69be450541 100644
--- a/cpp/test/prims/vMeasure.cu
+++ b/cpp/test/prims/vMeasure.cu
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <algorithm>
 #include <cuml/common/cuml_allocator.hpp>
 #include <iostream>
diff --git a/cpp/test/prims/weighted_mean.cu b/cpp/test/prims/weighted_mean.cu
index c5df1e0eaf..ef7e37a79c 100644
--- a/cpp/test/prims/weighted_mean.cu
+++ b/cpp/test/prims/weighted_mean.cu
@@ -16,8 +16,8 @@
 
 #include <gtest/gtest.h>
 #include <thrust/device_vector.h>
-#include <cuda_utils.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <stats/weighted_mean.cuh>
 #include "test_utils.h"
 
diff --git a/cpp/test/sg/cd_test.cu b/cpp/test/sg/cd_test.cu
index f4dfaa15cb..217aec8233 100644
--- a/cpp/test/sg/cd_test.cu
+++ b/cpp/test/sg/cd_test.cu
@@ -14,18 +14,17 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <test_utils.h>
-#include <matrix/matrix.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <solver/cd.cuh>
 
 namespace ML {
 namespace Solver {
 
 using namespace MLCommon;
-using namespace MLCommon::LinAlg;
 
 template <typename T>
 struct CdInputs {
diff --git a/cpp/test/sg/dbscan_test.cu b/cpp/test/sg/dbscan_test.cu
index bd26b84940..bd37ae389d 100644
--- a/cpp/test/sg/dbscan_test.cu
+++ b/cpp/test/sg/dbscan_test.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 
 #include <cuml/cluster/dbscan.hpp>
@@ -25,8 +25,8 @@
 #include <cuml/datasets/make_blobs.hpp>
 #include <cuml/metrics/metrics.hpp>
 
-#include <linalg/transpose.h>
 #include <raft/linalg/cublas_wrappers.h>
+#include <raft/linalg/transpose.h>
 
 #include <test_utils.h>
 
diff --git a/cpp/test/sg/decisiontree_batchedlevel_algo.cu b/cpp/test/sg/decisiontree_batchedlevel_algo.cu
index 710a3d8cd3..81aa996255 100644
--- a/cpp/test/sg/decisiontree_batchedlevel_algo.cu
+++ b/cpp/test/sg/decisiontree_batchedlevel_algo.cu
@@ -19,10 +19,10 @@
 #include <raft/linalg/cublas_wrappers.h>
 #include <test_utils.h>
 #include <common/iota.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/cuml.hpp>
 #include <decisiontree/batched-levelalgo/builder.cuh>
 #include <memory>
+#include <raft/cuda_utils.cuh>
 #include <random/make_blobs.cuh>
 #include <random/make_regression.cuh>
 
diff --git a/cpp/test/sg/fil_test.cu b/cpp/test/sg/fil_test.cu
index 2e8ade693b..6d9afee79d 100644
--- a/cpp/test/sg/fil_test.cu
+++ b/cpp/test/sg/fil_test.cu
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/fil/fil.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <treelite/c_api.h>
 #include <treelite/frontend.h>
 #include <treelite/tree.h>
 #include <cmath>
 #include <cstdio>
-#include <cuda_utils.cuh>
 #include <limits>
 #include <memory>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <utility>
 
 #define TL_CPP_CHECK(call) ASSERT(int(call) >= 0, "treelite call error")
diff --git a/cpp/test/sg/holtwinters_test.cu b/cpp/test/sg/holtwinters_test.cu
index 29ad994ae2..2e1508246c 100644
--- a/cpp/test/sg/holtwinters_test.cu
+++ b/cpp/test/sg/holtwinters_test.cu
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/tsa/holtwinters.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <algorithm>
-#include <cuda_utils.cuh>
 #include <cuml/common/logger.hpp>
+#include <raft/cuda_utils.cuh>
 #include "time_series_datasets.h"
 
 namespace ML {
diff --git a/cpp/test/sg/kmeans_test.cu b/cpp/test/sg/kmeans_test.cu
index 94a0df897c..d7598264fb 100644
--- a/cpp/test/sg/kmeans_test.cu
+++ b/cpp/test/sg/kmeans_test.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 
 #include <thrust/fill.h>
diff --git a/cpp/test/sg/knn_test.cu b/cpp/test/sg/knn_test.cu
index 036d9d4422..53f379f65b 100644
--- a/cpp/test/sg/knn_test.cu
+++ b/cpp/test/sg/knn_test.cu
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/neighbors/knn.hpp>
 #include <iostream>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <vector>
 
 #include <cuml/neighbors/knn.hpp>
diff --git a/cpp/test/sg/ols.cu b/cpp/test/sg/ols.cu
index 7dbc411eac..635610b11b 100644
--- a/cpp/test/sg/ols.cu
+++ b/cpp/test/sg/ols.cu
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <glm/ols.cuh>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 
 namespace ML {
diff --git a/cpp/test/sg/pca_test.cu b/cpp/test/sg/pca_test.cu
index c0b7b4a71d..8ff95dd744 100644
--- a/cpp/test/sg/pca_test.cu
+++ b/cpp/test/sg/pca_test.cu
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cublas_wrappers.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/decomposition/params.hpp>
 #include <pca/pca.cuh>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <vector>
 
 namespace ML {
diff --git a/cpp/test/sg/quasi_newton.cu b/cpp/test/sg/quasi_newton.cu
index 2b5f821307..e0c446735a 100644
--- a/cpp/test/sg/quasi_newton.cu
+++ b/cpp/test/sg/quasi_newton.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <test_utils.h>
 #include <cuml/linear_model/glm.hpp>
 #include <glm/qn/glm_linear.cuh>
diff --git a/cpp/test/sg/rf_accuracy_test.cu b/cpp/test/sg/rf_accuracy_test.cu
index 979e54e691..479432b89c 100644
--- a/cpp/test/sg/rf_accuracy_test.cu
+++ b/cpp/test/sg/rf_accuracy_test.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <cuml/ensemble/randomforest.hpp>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 
 namespace ML {
 
diff --git a/cpp/test/sg/rf_batched_classification_test.cu b/cpp/test/sg/rf_batched_classification_test.cu
index e67b21da1b..e811c5787a 100644
--- a/cpp/test/sg/rf_batched_classification_test.cu
+++ b/cpp/test/sg/rf_batched_classification_test.cu
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/datasets/make_blobs.hpp>
 #include <cuml/ensemble/randomforest.hpp>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 
diff --git a/cpp/test/sg/rf_batched_regression_test.cu b/cpp/test/sg/rf_batched_regression_test.cu
index a92c4f3717..a1dd3104bf 100644
--- a/cpp/test/sg/rf_batched_regression_test.cu
+++ b/cpp/test/sg/rf_batched_regression_test.cu
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
+#include <raft/cudart_utils.h>
 
 #include <gtest/gtest.h>
-#include <linalg/transpose.h>
+#include <raft/linalg/transpose.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/datasets/make_blobs.hpp>
 #include <cuml/datasets/make_regression.hpp>
 #include <cuml/ensemble/randomforest.hpp>
diff --git a/cpp/test/sg/rf_depth_test.cu b/cpp/test/sg/rf_depth_test.cu
index fd91505a62..1f235a0bcf 100644
--- a/cpp/test/sg/rf_depth_test.cu
+++ b/cpp/test/sg/rf_depth_test.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <cuml/ensemble/randomforest.hpp>
 #include <queue>
+#include <raft/cuda_utils.cuh>
 #include <random>
 
 namespace ML {
diff --git a/cpp/test/sg/rf_test.cu b/cpp/test/sg/rf_test.cu
index 73b06b59d0..5f8b2e053b 100644
--- a/cpp/test/sg/rf_test.cu
+++ b/cpp/test/sg/rf_test.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <cuml/ensemble/randomforest.hpp>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 
diff --git a/cpp/test/sg/rf_treelite_test.cu b/cpp/test/sg/rf_treelite_test.cu
index 2c1881c123..edd74942f2 100644
--- a/cpp/test/sg/rf_treelite_test.cu
+++ b/cpp/test/sg/rf_treelite_test.cu
@@ -14,22 +14,22 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <decisiontree/decisiontree_impl.h>
 #include <gtest/gtest.h>
-#include <linalg/gemv.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/gemv.h>
+#include <raft/linalg/transpose.h>
 #include <sys/stat.h>
 #include <test_utils.h>
 #include <treelite/c_api.h>
 #include <treelite/c_api_runtime.h>
 #include <cstdlib>
-#include <cuda_utils.cuh>
 #include <cuml/ensemble/randomforest.hpp>
 #include <fstream>
 #include <iostream>
 #include <limits>
-#include <random/rng.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/random/rng.cuh>
 #include <string>
 
 namespace ML {
diff --git a/cpp/test/sg/ridge.cu b/cpp/test/sg/ridge.cu
index e8baffe3fb..8e7f28621e 100644
--- a/cpp/test/sg/ridge.cu
+++ b/cpp/test/sg/ridge.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <glm/ridge.cuh>
+#include <raft/cuda_utils.cuh>
 
 namespace ML {
 namespace GLM {
diff --git a/cpp/test/sg/rproj_test.cu b/cpp/test/sg/rproj_test.cu
index ac39eed699..d246d812c5 100644
--- a/cpp/test/sg/rproj_test.cu
+++ b/cpp/test/sg/rproj_test.cu
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/random_projection/rproj_c.h>
 #include <gtest/gtest.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <test_utils.h>
-#include <cuda_utils.cuh>
 #include <distance/distance.cuh>
 #include <iostream>
+#include <raft/cuda_utils.cuh>
 #include <random>
 #include <vector>
 
diff --git a/cpp/test/sg/sgd.cu b/cpp/test/sg/sgd.cu
index 0e96fac7c3..5a73f58e52 100644
--- a/cpp/test/sg/sgd.cu
+++ b/cpp/test/sg/sgd.cu
@@ -14,18 +14,17 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <raft/linalg/cusolver_wrappers.h>
 #include <test_utils.h>
-#include <matrix/matrix.cuh>
+#include <raft/matrix/matrix.cuh>
 #include <solver/sgd.cuh>
 
 namespace ML {
 namespace Solver {
 
 using namespace MLCommon;
-using namespace MLCommon::LinAlg;
 
 template <typename T>
 struct SgdInputs {
diff --git a/cpp/test/sg/svc_test.cu b/cpp/test/sg/svc_test.cu
index ea6845f882..34a2c7092f 100644
--- a/cpp/test/sg/svc_test.cu
+++ b/cpp/test/sg/svc_test.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/svm/svm_model.h>
 #include <cuml/svm/svm_parameter.h>
 #include <gtest/gtest.h>
-#include <linalg/transpose.h>
+#include <raft/cudart_utils.h>
+#include <raft/linalg/transpose.h>
 #include <test_utils.h>
 #include <thrust/device_ptr.h>
 #include <thrust/fill.h>
@@ -27,18 +27,18 @@
 #include <common/cumlHandle.hpp>
 #include <common/device_buffer.hpp>
 #include <cub/cub.cuh>
-#include <cuda_utils.cuh>
 #include <cuml/common/logger.hpp>
 #include <cuml/datasets/make_blobs.hpp>
 #include <cuml/svm/svc.hpp>
 #include <cuml/svm/svr.hpp>
 #include <iostream>
-#include <linalg/binary_op.cuh>
-#include <linalg/map_then_reduce.cuh>
 #include <matrix/grammatrix.cuh>
 #include <matrix/kernelmatrices.cuh>
+#include <raft/cuda_utils.cuh>
+#include <raft/linalg/binary_op.cuh>
+#include <raft/linalg/map_then_reduce.cuh>
+#include <raft/random/rng.cuh>
 #include <random/make_blobs.cuh>
-#include <random/rng.cuh>
 #include <string>
 #include <svm/smoblocksolve.cuh>
 #include <svm/smosolver.cuh>
diff --git a/cpp/test/sg/trustworthiness_test.cu b/cpp/test/sg/trustworthiness_test.cu
index ad75079cd4..edfe28e881 100644
--- a/cpp/test/sg/trustworthiness_test.cu
+++ b/cpp/test/sg/trustworthiness_test.cu
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
-#include <cuda_utils.cuh>
+#include <raft/cudart_utils.h>
 #include <metrics/trustworthiness.cuh>
+#include <raft/cuda_utils.cuh>
 #include <vector>
 
 using namespace MLCommon;
diff --git a/cpp/test/sg/tsne_test.cu b/cpp/test/sg/tsne_test.cu
index 9812fb5e42..805b0bbf28 100644
--- a/cpp/test/sg/tsne_test.cu
+++ b/cpp/test/sg/tsne_test.cu
@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/tsne.h>
 #include <datasets/digits.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/common/logger.hpp>
 #include <iostream>
diff --git a/cpp/test/sg/tsvd_test.cu b/cpp/test/sg/tsvd_test.cu
index bb1e7106dc..ead521b290 100644
--- a/cpp/test/sg/tsvd_test.cu
+++ b/cpp/test/sg/tsvd_test.cu
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <common/cudart_utils.h>
 #include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
 #include <test_utils.h>
 #include <cuml/decomposition/params.hpp>
-#include <random/rng.cuh>
+#include <raft/random/rng.cuh>
 #include <tsvd/tsvd.cuh>
 #include <vector>
 
diff --git a/cpp/test/sg/umap_parametrizable_test.cu b/cpp/test/sg/umap_parametrizable_test.cu
index 0d79c92923..ffb2e39612 100644
--- a/cpp/test/sg/umap_parametrizable_test.cu
+++ b/cpp/test/sg/umap_parametrizable_test.cu
@@ -18,11 +18,10 @@
 #include <iostream>
 #include <vector>
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/umapparams.h>
 #include <datasets/digits.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/cuml.hpp>
 #include <cuml/datasets/make_blobs.hpp>
@@ -30,6 +29,7 @@
 #include <distance/distance.cuh>
 #include <linalg/reduce_rows_by_key.cuh>
 #include <metrics/trustworthiness.cuh>
+#include <raft/cuda_utils.cuh>
 #include <umap/runner.cuh>
 
 using namespace ML;
diff --git a/cpp/test/sg/umap_test.cu b/cpp/test/sg/umap_test.cu
index 2b89c448e0..1a1d2c70f6 100644
--- a/cpp/test/sg/umap_test.cu
+++ b/cpp/test/sg/umap_test.cu
@@ -18,17 +18,17 @@
 #include <iostream>
 #include <vector>
 
-#include <common/cudart_utils.h>
 #include <cuml/manifold/umapparams.h>
 #include <datasets/digits.h>
+#include <raft/cudart_utils.h>
 #include <common/device_buffer.hpp>
-#include <cuda_utils.cuh>
 #include <cuml/common/cuml_allocator.hpp>
 #include <cuml/common/logger.hpp>
 #include <cuml/cuml.hpp>
 #include <cuml/neighbors/knn.hpp>
 #include <distance/distance.cuh>
 #include <metrics/trustworthiness.cuh>
+#include <raft/cuda_utils.cuh>
 #include <umap/runner.cuh>
 
 using namespace ML;