From e9cd4b7c9e730ec86d33e555d54ee426e0d0f8ce Mon Sep 17 00:00:00 2001 From: viclafargue Date: Wed, 8 Dec 2021 18:55:20 +0100 Subject: [PATCH 1/5] Remove RAFT memory management --- cpp/examples/symreg/symreg_example.cpp | 9 +- cpp/test/prims/hinge.cu | 258 +++++---- cpp/test/prims/jones_transform.cu | 128 +++-- cpp/test/prims/knn_classify.cu | 76 ++- cpp/test/prims/knn_regression.cu | 75 ++- cpp/test/prims/linearReg.cu | 256 +++++---- cpp/test/prims/logisticReg.cu | 258 +++++---- cpp/test/prims/make_blobs.cu | 72 +-- cpp/test/prims/make_regression.cu | 69 +-- cpp/test/prims/penalty.cu | 152 +++--- cpp/test/prims/reduce_rows_by_key.cu | 114 ++-- cpp/test/prims/score.cu | 55 +- cpp/test/prims/ternary_op.cu | 75 ++- cpp/test/sg/cd_test.cu | 143 +++-- cpp/test/sg/dbscan_test.cu | 68 +-- .../sg/decisiontree_batchedlevel_unittest.cu | 15 +- cpp/test/sg/fil_test.cu | 141 +++-- cpp/test/sg/holtwinters_test.cu | 64 +-- cpp/test/sg/knn_test.cu | 154 +++--- cpp/test/sg/ols.cu | 239 ++++---- cpp/test/sg/pca_test.cu | 212 ++++---- cpp/test/sg/ridge.cu | 232 ++++---- cpp/test/sg/rproj_test.cu | 142 +++-- cpp/test/sg/sgd.cu | 203 ++++--- cpp/test/sg/shap_kernel.cu | 53 +- cpp/test/sg/svc_test.cu | 509 ++++++++---------- cpp/test/sg/tsvd_test.cu | 106 ++-- 27 files changed, 1863 insertions(+), 2015 deletions(-) diff --git a/cpp/examples/symreg/symreg_example.cpp b/cpp/examples/symreg/symreg_example.cpp index a33d9af8bf..f8102c8ede 100644 --- a/cpp/examples/symreg/symreg_example.cpp +++ b/cpp/examples/symreg/symreg_example.cpp @@ -217,8 +217,6 @@ int main(int argc, char* argv[]) rmm::device_uvector dy_pred(n_test_rows, stream); rmm::device_scalar d_score{stream}; - cg::program_t d_finalprogs; // pointer to last generation ASTs on device - CUDA_RT_CALL(cudaMemcpyAsync(dX_train.data(), X_train.data(), sizeof(float) * dX_train.size(), @@ -247,7 +245,7 @@ int main(int argc, char* argv[]) dw_test.data(), w_test.data(), sizeof(float) * n_test_rows, cudaMemcpyHostToDevice, stream)); // Initialize AST - raft::allocate(d_finalprogs, params.population_size, stream); + rmm::device_uvector d_finalprogs(params.population_size, stream); std::vector> history; history.reserve(params.generations); @@ -273,7 +271,7 @@ int main(int argc, char* argv[]) n_train_rows, n_cols, params, - d_finalprogs, + d_finalprogs.data(), history); cudaEventRecord(stop, stream); @@ -311,7 +309,7 @@ int main(int argc, char* argv[]) std::cout << "Beginning Inference on test dataset " << std::endl; cudaEventRecord(start, stream); cuml::genetic::symRegPredict( - handle, dX_test.data(), n_test_rows, d_finalprogs + best_idx, dy_pred.data()); + handle, dX_test.data(), n_test_rows, d_finalprogs.data() + best_idx, dy_pred.data()); std::vector hy_pred(n_test_rows, 0.0f); CUDA_RT_CALL(cudaMemcpy( @@ -339,7 +337,6 @@ int main(int argc, char* argv[]) /* ======================= Reset data ======================= */ - raft::deallocate(d_finalprogs, stream); CUDA_RT_CALL(cudaEventDestroy(start)); CUDA_RT_CALL(cudaEventDestroy(stop)); CUDA_RT_CALL(cudaStreamDestroy(stream)); diff --git a/cpp/test/prims/hinge.cu b/cpp/test/prims/hinge.cu index b0824fe893..1aa9048e4c 100644 --- a/cpp/test/prims/hinge.cu +++ b/cpp/test/prims/hinge.cu @@ -17,7 +17,9 @@ #include #include #include +#include #include +#include #include "test_utils.h" namespace MLCommon { @@ -33,216 +35,196 @@ struct HingeLossInputs { template class HingeLossTest : public ::testing::TestWithParam> { + public: + HingeLossTest() + : params(::testing::TestWithParam>::GetParam()), + stream(handle.get_stream()), + in(params.len, stream), + out(1, stream), + out_lasso(1, stream), + out_ridge(1, stream), + out_elasticnet(1, stream), + out_grad(params.n_cols, stream), + out_lasso_grad(params.n_cols, stream), + out_ridge_grad(params.n_cols, stream), + out_elasticnet_grad(params.n_cols, stream), + out_ref(1, stream), + out_lasso_ref(1, stream), + out_ridge_ref(1, stream), + out_elasticnet_ref(1, stream), + out_grad_ref(params.n_cols, stream), + out_lasso_grad_ref(params.n_cols, stream), + out_ridge_grad_ref(params.n_cols, stream), + out_elasticnet_grad_ref(params.n_cols, stream) + { + } + protected: void SetUp() override { - params = ::testing::TestWithParam>::GetParam(); int len = params.len; int n_rows = params.n_rows; int n_cols = params.n_cols; - T *labels, *coef; - - raft::handle_t handle; - cudaStream_t stream = handle.get_stream(); - - raft::allocate(in, len, stream); - raft::allocate(out, 1, stream); - raft::allocate(out_lasso, 1, stream); - raft::allocate(out_ridge, 1, stream); - raft::allocate(out_elasticnet, 1, stream); - raft::allocate(out_grad, n_cols, stream); - raft::allocate(out_lasso_grad, n_cols, stream); - raft::allocate(out_ridge_grad, n_cols, stream); - raft::allocate(out_elasticnet_grad, n_cols, stream); - raft::allocate(out_ref, 1, stream); - raft::allocate(out_lasso_ref, 1, stream); - raft::allocate(out_ridge_ref, 1, stream); - raft::allocate(out_elasticnet_ref, 1, stream); - raft::allocate(out_grad_ref, n_cols, stream); - raft::allocate(out_lasso_grad_ref, n_cols, stream); - raft::allocate(out_ridge_grad_ref, n_cols, stream); - raft::allocate(out_elasticnet_grad_ref, n_cols, stream); - - raft::allocate(labels, params.n_rows, stream); - raft::allocate(coef, params.n_cols, stream); + rmm::device_uvector labels(params.n_rows, stream); + rmm::device_uvector coef(params.n_cols, stream); T h_in[len] = {0.1, 0.35, -0.9, -1.4, 2.0, 3.1}; - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); T h_labels[n_rows] = {0.3, 2.0, -1.1}; - raft::update_device(labels, h_labels, n_rows, stream); + raft::update_device(labels.data(), h_labels, n_rows, stream); T h_coef[n_cols] = {0.35, -0.24}; - raft::update_device(coef, h_coef, n_cols, stream); + raft::update_device(coef.data(), h_coef, n_cols, stream); T h_out_ref[1] = {2.6037}; - raft::update_device(out_ref, h_out_ref, 1, stream); + raft::update_device(out_ref.data(), h_out_ref, 1, stream); T h_out_lasso_ref[1] = {2.9577}; - raft::update_device(out_lasso_ref, h_out_lasso_ref, 1, stream); + raft::update_device(out_lasso_ref.data(), h_out_lasso_ref, 1, stream); T h_out_ridge_ref[1] = {2.71176}; - raft::update_device(out_ridge_ref, h_out_ridge_ref, 1, stream); + raft::update_device(out_ridge_ref.data(), h_out_ridge_ref, 1, stream); T h_out_elasticnet_ref[1] = {2.83473}; - raft::update_device(out_elasticnet_ref, h_out_elasticnet_ref, 1, stream); + raft::update_device(out_elasticnet_ref.data(), h_out_elasticnet_ref, 1, stream); T h_out_grad_ref[n_cols] = {-0.24333, -1.1933}; - raft::update_device(out_grad_ref, h_out_grad_ref, n_cols, stream); + raft::update_device(out_grad_ref.data(), h_out_grad_ref, n_cols, stream); T h_out_lasso_grad_ref[n_cols] = {0.3566, -1.7933}; - raft::update_device(out_lasso_grad_ref, h_out_lasso_grad_ref, n_cols, stream); + raft::update_device(out_lasso_grad_ref.data(), h_out_lasso_grad_ref, n_cols, stream); T h_out_ridge_grad_ref[n_cols] = {0.1766, -1.4813}; - raft::update_device(out_ridge_grad_ref, h_out_ridge_grad_ref, n_cols, stream); + raft::update_device(out_ridge_grad_ref.data(), h_out_ridge_grad_ref, n_cols, stream); T h_out_elasticnet_grad_ref[n_cols] = {0.2666, -1.63733}; - raft::update_device(out_elasticnet_grad_ref, h_out_elasticnet_grad_ref, n_cols, stream); + raft::update_device(out_elasticnet_grad_ref.data(), h_out_elasticnet_grad_ref, n_cols, stream); T alpha = 0.6; T l1_ratio = 0.5; hingeLoss(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out, + labels.data(), + coef.data(), + out.data(), penalty::NONE, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); hingeLossGrads(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_grad, + labels.data(), + coef.data(), + out_grad.data(), penalty::NONE, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); hingeLoss(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_lasso, + labels.data(), + coef.data(), + out_lasso.data(), penalty::L1, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); hingeLossGrads(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_lasso_grad, + labels.data(), + coef.data(), + out_lasso_grad.data(), penalty::L1, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); hingeLoss(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_ridge, + labels.data(), + coef.data(), + out_ridge.data(), penalty::L2, alpha, l1_ratio, stream); hingeLossGrads(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_ridge_grad, + labels.data(), + coef.data(), + out_ridge_grad.data(), penalty::L2, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); + raft::update_device(in.data(), h_in, len, stream); hingeLoss(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_elasticnet, + labels.data(), + coef.data(), + out_elasticnet.data(), penalty::ELASTICNET, alpha, l1_ratio, stream); hingeLossGrads(handle, - in, + in.data(), params.n_rows, params.n_cols, - labels, - coef, - out_elasticnet_grad, + labels.data(), + coef.data(), + out_elasticnet_grad.data(), penalty::ELASTICNET, alpha, l1_ratio, stream); - raft::update_device(in, h_in, len, stream); - - CUDA_CHECK(cudaFree(labels)); - CUDA_CHECK(cudaFree(coef)); - } - - void TearDown() override - { - CUDA_CHECK(cudaFree(in)); - CUDA_CHECK(cudaFree(out)); - CUDA_CHECK(cudaFree(out_lasso)); - CUDA_CHECK(cudaFree(out_ridge)); - CUDA_CHECK(cudaFree(out_elasticnet)); - CUDA_CHECK(cudaFree(out_grad)); - CUDA_CHECK(cudaFree(out_lasso_grad)); - CUDA_CHECK(cudaFree(out_ridge_grad)); - CUDA_CHECK(cudaFree(out_elasticnet_grad)); - CUDA_CHECK(cudaFree(out_ref)); - CUDA_CHECK(cudaFree(out_lasso_ref)); - CUDA_CHECK(cudaFree(out_ridge_ref)); - CUDA_CHECK(cudaFree(out_elasticnet_ref)); - CUDA_CHECK(cudaFree(out_grad_ref)); - CUDA_CHECK(cudaFree(out_lasso_grad_ref)); - CUDA_CHECK(cudaFree(out_ridge_grad_ref)); - CUDA_CHECK(cudaFree(out_elasticnet_grad_ref)); + raft::update_device(in.data(), h_in, len, stream); } protected: HingeLossInputs params; - T* in; - T *out, *out_lasso, *out_ridge, *out_elasticnet; - T *out_ref, *out_lasso_ref, *out_ridge_ref, *out_elasticnet_ref; - T *out_grad, *out_lasso_grad, *out_ridge_grad, *out_elasticnet_grad; - T *out_grad_ref, *out_lasso_grad_ref, *out_ridge_grad_ref, *out_elasticnet_grad_ref; + + raft::handle_t handle; + cudaStream_t stream; + + rmm::device_uvector in, out, out_lasso, out_ridge, out_elasticnet; + rmm::device_uvector out_ref, out_lasso_ref, out_ridge_ref, out_elasticnet_ref; + rmm::device_uvector out_grad, out_lasso_grad, out_ridge_grad, out_elasticnet_grad; + rmm::device_uvector out_grad_ref, out_lasso_grad_ref, out_ridge_grad_ref, + out_elasticnet_grad_ref; }; const std::vector> inputsf = {{0.01f, 3, 2, 6}}; @@ -252,32 +234,37 @@ const std::vector> inputsd = {{0.01, 3, 2, 6}}; typedef HingeLossTest HingeLossTestF; TEST_P(HingeLossTestF, Result) { - ASSERT_TRUE(raft::devArrMatch(out_ref, out, 1, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE( - raft::devArrMatch(out_lasso_ref, out_lasso, 1, raft::CompareApprox(params.tolerance))); - - ASSERT_TRUE( - raft::devArrMatch(out_ridge_ref, out_ridge, 1, raft::CompareApprox(params.tolerance))); + raft::devArrMatch(out_ref.data(), out.data(), 1, raft::CompareApprox(params.tolerance))); ASSERT_TRUE(raft::devArrMatch( - out_elasticnet_ref, out_elasticnet, 1, raft::CompareApprox(params.tolerance))); + out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox(params.tolerance))); ASSERT_TRUE(raft::devArrMatch( - out_grad_ref, out_grad, params.n_cols, raft::CompareApprox(params.tolerance))); + out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox(params.tolerance))); + + ASSERT_TRUE(raft::devArrMatch(out_elasticnet_ref.data(), + out_elasticnet.data(), + 1, + raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref, - out_lasso_grad, + ASSERT_TRUE(raft::devArrMatch(out_grad_ref.data(), + out_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref, - out_ridge_grad, + ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref.data(), + out_lasso_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref, - out_elasticnet_grad, + ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref.data(), + out_ridge_grad.data(), + params.n_cols, + raft::CompareApprox(params.tolerance))); + + ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref.data(), + out_elasticnet_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); } @@ -285,32 +272,37 @@ TEST_P(HingeLossTestF, Result) typedef HingeLossTest HingeLossTestD; TEST_P(HingeLossTestD, Result) { - ASSERT_TRUE(raft::devArrMatch(out_ref, out, 1, raft::CompareApprox(params.tolerance))); - - ASSERT_TRUE( - raft::devArrMatch(out_lasso_ref, out_lasso, 1, raft::CompareApprox(params.tolerance))); - - ASSERT_TRUE( - raft::devArrMatch(out_ridge_ref, out_ridge, 1, raft::CompareApprox(params.tolerance))); + ASSERT_TRUE(raft::devArrMatch( + out_ref.data(), out.data(), 1, raft::CompareApprox(params.tolerance))); ASSERT_TRUE(raft::devArrMatch( - out_elasticnet_ref, out_elasticnet, 1, raft::CompareApprox(params.tolerance))); + out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox(params.tolerance))); ASSERT_TRUE(raft::devArrMatch( - out_grad_ref, out_grad, params.n_cols, raft::CompareApprox(params.tolerance))); + out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox(params.tolerance))); + + ASSERT_TRUE(raft::devArrMatch(out_elasticnet_ref.data(), + out_elasticnet.data(), + 1, + raft::CompareApprox(params.tolerance))); + + ASSERT_TRUE(raft::devArrMatch(out_grad_ref.data(), + out_grad.data(), + params.n_cols, + raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref, - out_lasso_grad, + ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref.data(), + out_lasso_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref, - out_ridge_grad, + ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref.data(), + out_ridge_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref, - out_elasticnet_grad, + ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref.data(), + out_elasticnet_grad.data(), params.n_cols, raft::CompareApprox(params.tolerance))); } diff --git a/cpp/test/prims/jones_transform.cu b/cpp/test/prims/jones_transform.cu index 4455c5b720..28d71b19ea 100644 --- a/cpp/test/prims/jones_transform.cu +++ b/cpp/test/prims/jones_transform.cu @@ -16,7 +16,9 @@ #include #include #include +#include #include +#include #include #include "test_utils.h" @@ -35,15 +37,38 @@ template class JonesTransTest : public ::testing::TestWithParam { + public: + JonesTransTest() + : params(::testing::TestWithParam::GetParam()), + stream(handle.get_stream()), + nElements(params.batchSize * params.pValue), + d_golden_ar_trans(nElements, stream), + d_computed_ar_trans(nElements, stream), + d_params(nElements, stream), + d_golden_ma_trans(nElements, stream), + d_computed_ma_trans(nElements, stream), + d_computed_ar_invtrans(nElements, stream), + d_computed_ma_invtrans(nElements, stream) + { + CUDA_CHECK(cudaMemsetAsync( + d_golden_ar_trans.data(), 0, d_golden_ar_trans.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync( + d_computed_ar_trans.data(), 0, d_computed_ar_trans.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync(d_params.data(), 0, d_params.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync( + d_golden_ma_trans.data(), 0, d_golden_ma_trans.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync( + d_computed_ma_trans.data(), 0, d_computed_ma_trans.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync( + d_computed_ar_invtrans.data(), 0, d_computed_ar_invtrans.size() * sizeof(DataT), stream)); + CUDA_CHECK(cudaMemsetAsync( + d_computed_ma_invtrans.data(), 0, d_computed_ma_invtrans.size() * sizeof(DataT), stream)); + } + protected: // the constructor void SetUp() override { - // getting the parameters - params = ::testing::TestWithParam::GetParam(); - - nElements = params.batchSize * params.pValue; - // generating random value test input that is stored in row major std::vector arr1(nElements, 0); std::random_device rd; @@ -91,17 +116,19 @@ template } // allocating and initializing device memory - CUDA_CHECK(cudaStreamCreate(&stream)); - raft::allocate(d_golden_ar_trans, nElements, stream, true); - raft::allocate(d_computed_ar_trans, nElements, stream, true); - raft::allocate(d_params, nElements, stream, true); - raft::update_device(d_params, &arr1[0], (size_t)nElements, stream); - raft::update_device(d_golden_ar_trans, newParams, (size_t)nElements, stream); + raft::update_device(d_params.data(), &arr1[0], (size_t)nElements, stream); + raft::update_device(d_golden_ar_trans.data(), newParams, (size_t)nElements, stream); // calling the ar_trans_param CUDA implementation - MLCommon::TimeSeries::jones_transform( - d_params, params.batchSize, params.pValue, d_computed_ar_trans, true, false, stream, false); + MLCommon::TimeSeries::jones_transform(d_params.data(), + params.batchSize, + params.pValue, + d_computed_ar_trans.data(), + true, + false, + stream, + false); //>>>>>>>>> MA transform golden output generation<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @@ -138,68 +165,49 @@ template } } - // allocating and initializing device memory - raft::allocate(d_golden_ma_trans, nElements, stream, true); - raft::allocate(d_computed_ma_trans, nElements, stream, true); - - raft::update_device(d_golden_ma_trans, newParams, (size_t)nElements, stream); + raft::update_device(d_golden_ma_trans.data(), newParams, (size_t)nElements, stream); // calling the ma_param_transform CUDA implementation - MLCommon::TimeSeries::jones_transform( - d_params, params.batchSize, params.pValue, d_computed_ma_trans, false, false, stream, false); + MLCommon::TimeSeries::jones_transform(d_params.data(), + params.batchSize, + params.pValue, + d_computed_ma_trans.data(), + false, + false, + stream, + false); //>>>>>>>>> AR inverse transform <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< - // allocating and initializing device memory - raft::allocate(d_computed_ar_invtrans, nElements, stream, true); - // calling the ar_param_inverse_transform CUDA implementation - MLCommon::TimeSeries::jones_transform(d_computed_ar_trans, + MLCommon::TimeSeries::jones_transform(d_computed_ar_trans.data(), params.batchSize, params.pValue, - d_computed_ar_invtrans, + d_computed_ar_invtrans.data(), true, true, stream); //>>>>>>>>> MA inverse transform <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< - raft::allocate(d_computed_ma_invtrans, nElements, stream, true); - // calling the ma_param_inverse_transform CUDA implementation - MLCommon::TimeSeries::jones_transform(d_computed_ma_trans, + MLCommon::TimeSeries::jones_transform(d_computed_ma_trans.data(), params.batchSize, params.pValue, - d_computed_ma_invtrans, + d_computed_ma_invtrans.data(), false, true, stream); } - // the destructor - void TearDown() override - { - CUDA_CHECK(cudaFree(d_computed_ar_trans)); - CUDA_CHECK(cudaFree(d_computed_ma_trans)); - CUDA_CHECK(cudaFree(d_computed_ar_invtrans)); - CUDA_CHECK(cudaFree(d_computed_ma_invtrans)); - CUDA_CHECK(cudaFree(d_golden_ar_trans)); - CUDA_CHECK(cudaFree(d_golden_ma_trans)); - CUDA_CHECK(cudaFree(d_params)); - CUDA_CHECK(cudaStreamDestroy(stream)); - } + raft::handle_t handle; + cudaStream_t stream = 0; // declaring the data values JonesTransParam params; - DataT* d_golden_ar_trans = nullptr; - DataT* d_golden_ma_trans = nullptr; - DataT* d_computed_ar_trans = nullptr; - DataT* d_computed_ma_trans = nullptr; - DataT* d_computed_ar_invtrans = nullptr; - DataT* d_computed_ma_invtrans = nullptr; - DataT* d_params = nullptr; - cudaStream_t stream = 0; - int nElements = -1; + rmm::device_uvector d_golden_ar_trans, d_golden_ma_trans, d_computed_ar_trans, + d_computed_ma_trans, d_computed_ar_invtrans, d_computed_ma_invtrans, d_params; + int nElements = -1; }; // setting test parameter values @@ -224,12 +232,12 @@ const std::vector inputs = {{500, 4, 0.001}, typedef JonesTransTest JonesTransTestClass; TEST_P(JonesTransTestClass, Result) { - ASSERT_TRUE(raft::devArrMatch(d_golden_ar_trans, - d_computed_ar_trans, + ASSERT_TRUE(raft::devArrMatch(d_golden_ar_trans.data(), + d_computed_ar_trans.data(), nElements, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch(d_golden_ma_trans, - d_computed_ma_trans, + ASSERT_TRUE(raft::devArrMatch(d_golden_ma_trans.data(), + d_computed_ma_trans.data(), nElements, raft::CompareApprox(params.tolerance))); /* @@ -238,10 +246,14 @@ TEST_P(JonesTransTestClass, Result) transformed coefficients -> ar_param_inverse_transform()/ma_param_inverse_transform() -> initially generated random coefficients */ - ASSERT_TRUE(raft::devArrMatch( - d_computed_ma_invtrans, d_params, nElements, raft::CompareApprox(params.tolerance))); - ASSERT_TRUE(raft::devArrMatch( - d_computed_ar_invtrans, d_params, nElements, raft::CompareApprox(params.tolerance))); + ASSERT_TRUE(raft::devArrMatch(d_computed_ma_invtrans.data(), + d_params.data(), + nElements, + raft::CompareApprox(params.tolerance))); + ASSERT_TRUE(raft::devArrMatch(d_computed_ar_invtrans.data(), + d_params.data(), + nElements, + raft::CompareApprox(params.tolerance))); } INSTANTIATE_TEST_CASE_P(JonesTrans, JonesTransTestClass, ::testing::ValuesIn(inputs)); diff --git a/cpp/test/prims/knn_classify.cu b/cpp/test/prims/knn_classify.cu index c9be1e0d66..41107f36f6 100644 --- a/cpp/test/prims/knn_classify.cu +++ b/cpp/test/prims/knn_classify.cu @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -38,24 +39,24 @@ struct KNNClassifyInputs { }; class KNNClassifyTest : public ::testing::TestWithParam { + public: + KNNClassifyTest() + : params(::testing::TestWithParam::GetParam()), + stream(handle.get_stream()), + train_samples(params.rows * params.cols, stream), + train_labels(params.rows, stream), + pred_labels(params.rows, stream), + knn_indices(params.rows * params.k, stream), + knn_dists(params.rows * params.k, stream) + { + basicTest(); + } + protected: void basicTest() { - raft::handle_t handle; - cudaStream_t stream = handle.get_stream(); - - params = ::testing::TestWithParam::GetParam(); - - raft::allocate(train_samples, params.rows * params.cols, stream); - raft::allocate(train_labels, params.rows, stream); - - raft::allocate(pred_labels, params.rows, stream); - - raft::allocate(knn_indices, params.rows * params.k, stream); - raft::allocate(knn_dists, params.rows * params.k, stream); - - MLCommon::Random::make_blobs(train_samples, - train_labels, + MLCommon::Random::make_blobs(train_samples.data(), + train_labels.data(), params.rows, params.cols, params.n_labels, @@ -66,25 +67,26 @@ class KNNClassifyTest : public ::testing::TestWithParam { params.cluster_std); rmm::device_uvector unique_labels(0, stream); - auto n_classes = raft::label::getUniquelabels(unique_labels, train_labels, params.rows, stream); + auto n_classes = + raft::label::getUniquelabels(unique_labels, train_labels.data(), params.rows, stream); std::vector ptrs(1); std::vector sizes(1); - ptrs[0] = train_samples; + ptrs[0] = train_samples.data(); sizes[0] = params.rows; raft::spatial::knn::brute_force_knn(handle, ptrs, sizes, params.cols, - train_samples, + train_samples.data(), params.rows, - knn_indices, - knn_dists, + knn_indices.data(), + knn_dists.data(), params.k); std::vector y; - y.push_back(train_labels); + y.push_back(train_labels.data()); std::vector uniq_labels; uniq_labels.push_back(unique_labels.data()); @@ -92,8 +94,8 @@ class KNNClassifyTest : public ::testing::TestWithParam { std::vector n_unique; n_unique.push_back(n_classes); - knn_classify(pred_labels, - knn_indices, + knn_classify(pred_labels.data(), + knn_indices.data(), y, params.rows, params.rows, @@ -105,35 +107,25 @@ class KNNClassifyTest : public ::testing::TestWithParam { CUDA_CHECK(cudaStreamSynchronize(stream)); } - void SetUp() override { basicTest(); } - - void TearDown() override - { - CUDA_CHECK(cudaFree(train_samples)); - CUDA_CHECK(cudaFree(train_labels)); - - CUDA_CHECK(cudaFree(pred_labels)); - - CUDA_CHECK(cudaFree(knn_indices)); - CUDA_CHECK(cudaFree(knn_dists)); - } - protected: KNNClassifyInputs params; + raft::handle_t handle; + cudaStream_t stream; - float* train_samples; - int* train_labels; + rmm::device_uvector train_samples; + rmm::device_uvector train_labels; - int* pred_labels; + rmm::device_uvector pred_labels; - int64_t* knn_indices; - float* knn_dists; + rmm::device_uvector knn_indices; + rmm::device_uvector knn_dists; }; typedef KNNClassifyTest KNNClassifyTestF; TEST_P(KNNClassifyTestF, Fit) { - ASSERT_TRUE(devArrMatch(train_labels, pred_labels, params.rows, raft::Compare())); + ASSERT_TRUE( + devArrMatch(train_labels.data(), pred_labels.data(), params.rows, raft::Compare())); } const std::vector inputsf = {{100, 10, 2, 0.01f, 2}, diff --git a/cpp/test/prims/knn_regression.cu b/cpp/test/prims/knn_regression.cu index 37afb62e8f..fadf9f4af0 100644 --- a/cpp/test/prims/knn_regression.cu +++ b/cpp/test/prims/knn_regression.cu @@ -20,9 +20,11 @@ #include #include