From 3a07b1edf8e52f0732b2675d237bf935048d27fd Mon Sep 17 00:00:00 2001 From: amdsc21 <96135754+amdsc21@users.noreply.github.com> Date: Sat, 11 Mar 2023 02:17:05 +0100 Subject: [PATCH] complete test porting --- src/common/device_helpers.cuh | 7 ++ tests/cpp/c_api/test_c_api.cc | 2 + tests/cpp/common/test_algorithm.hip | 2 + tests/cpp/common/test_bitfield.cu | 2 +- tests/cpp/common/test_bitfield.hip | 4 + tests/cpp/common/test_device_helpers.cu | 10 +++ tests/cpp/common/test_device_helpers.hip | 2 + .../common/test_gpu_compressed_iterator.cu | 4 + .../common/test_gpu_compressed_iterator.hip | 2 + tests/cpp/common/test_hist_util.cu | 6 ++ tests/cpp/common/test_hist_util.h | 5 +- tests/cpp/common/test_hist_util.hip | 4 + tests/cpp/common/test_host_device_vector.cu | 12 +++ tests/cpp/common/test_host_device_vector.hip | 4 + tests/cpp/common/test_linalg.hip | 2 + tests/cpp/common/test_quantile.cu | 4 + tests/cpp/common/test_quantile.hip | 2 + tests/cpp/common/test_span.cu | 89 +++++++++++++++++++ tests/cpp/common/test_span.hip | 4 + tests/cpp/common/test_stats.cc | 12 +-- tests/cpp/common/test_stats.hip | 2 + tests/cpp/common/test_threading_utils.hip | 2 + tests/cpp/common/test_transform_range.cc | 4 +- tests/cpp/gbm/test_gbtree.cc | 12 +-- 24 files changed, 183 insertions(+), 16 deletions(-) diff --git a/src/common/device_helpers.cuh b/src/common/device_helpers.cuh index 58300d06c..31b561791 100644 --- a/src/common/device_helpers.cuh +++ b/src/common/device_helpers.cuh @@ -2,6 +2,9 @@ * Copyright 2017-2023 XGBoost contributors */ #pragma once + +#if defined(XGBOOST_USE_CUDA) + #include // thrust::upper_bound #include #include @@ -1381,3 +1384,7 @@ class LDGIterator { } }; } // namespace dh + +#elif defined(XGBOOST_USE_HIP) +#include" device_helpers.hip.h" +#endif diff --git a/tests/cpp/c_api/test_c_api.cc b/tests/cpp/c_api/test_c_api.cc index 675da940c..a2595d360 100644 --- a/tests/cpp/c_api/test_c_api.cc +++ b/tests/cpp/c_api/test_c_api.cc @@ -364,6 +364,8 @@ TEST(CAPI, BuildInfo) { ASSERT_TRUE(get(loaded).find("USE_OPENMP") != get(loaded).cend()); ASSERT_TRUE(get(loaded).find("USE_CUDA") != get(loaded).cend()); ASSERT_TRUE(get(loaded).find("USE_NCCL") != get(loaded).cend()); + ASSERT_TRUE(get(loaded).find("USE_HIP") != get(loaded).cend()); + ASSERT_TRUE(get(loaded).find("USE_RCCL") != get(loaded).cend()); } TEST(CAPI, NullPtr) { diff --git a/tests/cpp/common/test_algorithm.hip b/tests/cpp/common/test_algorithm.hip index e69de29bb..01b8db8a9 100644 --- a/tests/cpp/common/test_algorithm.hip +++ b/tests/cpp/common/test_algorithm.hip @@ -0,0 +1,2 @@ + +#include "test_algorithm.cu" diff --git a/tests/cpp/common/test_bitfield.cu b/tests/cpp/common/test_bitfield.cu index 98fbd2ad1..49b8cbed5 100644 --- a/tests/cpp/common/test_bitfield.cu +++ b/tests/cpp/common/test_bitfield.cu @@ -66,4 +66,4 @@ TEST(BitField, GPUAnd) { ASSERT_TRUE(outputs.Check(i)); } } -} // namespace xgboost \ No newline at end of file +} // namespace xgboost diff --git a/tests/cpp/common/test_bitfield.hip b/tests/cpp/common/test_bitfield.hip index e69de29bb..d5a8d396e 100644 --- a/tests/cpp/common/test_bitfield.hip +++ b/tests/cpp/common/test_bitfield.hip @@ -0,0 +1,4 @@ + +#if defined(XGBOOST_USE_HIP) +#include "test_bitfield.cu" +#endif diff --git a/tests/cpp/common/test_device_helpers.cu b/tests/cpp/common/test_device_helpers.cu index 7ae8faf03..ae4cffad0 100644 --- a/tests/cpp/common/test_device_helpers.cu +++ b/tests/cpp/common/test_device_helpers.cu @@ -126,7 +126,13 @@ TEST(DeviceHelpers, Reduce) { size_t kSize = std::numeric_limits::max(); auto it = thrust::make_counting_iterator(0ul); dh::XGBCachingDeviceAllocator alloc; + +#if defined(XGBOOST_USE_CUDA) auto batched = dh::Reduce(thrust::cuda::par(alloc), it, it + kSize, 0ul, thrust::maximum{}); +#elif defined(XGBOOST_USE_HIP) + auto batched = dh::Reduce(thrust::hip::par(alloc), it, it + kSize, 0ul, thrust::maximum{}); +#endif + CHECK_EQ(batched, kSize - 1); } @@ -170,6 +176,10 @@ TEST(Allocator, OOM) { ASSERT_THROW({dh::caching_device_vector vec(size);}, dmlc::Error); ASSERT_THROW({dh::device_vector vec(size);}, dmlc::Error); // Clear last error so we don't fail subsequent tests +#if defined(XGBOOST_USE_CUDA) cudaGetLastError(); +#elif defined(XGBOOST_USE_HIP) + hipGetLastError(); +#endif } } // namespace xgboost diff --git a/tests/cpp/common/test_device_helpers.hip b/tests/cpp/common/test_device_helpers.hip index e69de29bb..90b0d78c0 100644 --- a/tests/cpp/common/test_device_helpers.hip +++ b/tests/cpp/common/test_device_helpers.hip @@ -0,0 +1,2 @@ + +#include "test_device_helpers.cu" diff --git a/tests/cpp/common/test_gpu_compressed_iterator.cu b/tests/cpp/common/test_gpu_compressed_iterator.cu index 779202a62..1ffc4494e 100644 --- a/tests/cpp/common/test_gpu_compressed_iterator.cu +++ b/tests/cpp/common/test_gpu_compressed_iterator.cu @@ -32,7 +32,11 @@ struct ReadSymbolFunction { }; TEST(CompressedIterator, TestGPU) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif std::vector test_cases = {1, 3, 426, 21, 64, 256, 100000, INT32_MAX}; int num_elements = 1000; int repetitions = 1000; diff --git a/tests/cpp/common/test_gpu_compressed_iterator.hip b/tests/cpp/common/test_gpu_compressed_iterator.hip index e69de29bb..457162438 100644 --- a/tests/cpp/common/test_gpu_compressed_iterator.hip +++ b/tests/cpp/common/test_gpu_compressed_iterator.hip @@ -0,0 +1,2 @@ + +#include "test_gpu_compressed_iterator.cu" diff --git a/tests/cpp/common/test_hist_util.cu b/tests/cpp/common/test_hist_util.cu index 45948b711..b91cf0b33 100644 --- a/tests/cpp/common/test_hist_util.cu +++ b/tests/cpp/common/test_hist_util.cu @@ -53,7 +53,13 @@ TEST(HistUtil, SketchBatchNumElements) { #endif // defined(XGBOOST_USE_RMM) && XGBOOST_USE_RMM == 1 size_t constexpr kCols = 10000; int device; + +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaGetDevice(&device)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipGetDevice(&device)); +#endif + auto avail = static_cast(dh::AvailableMemory(device) * 0.8); auto per_elem = detail::BytesPerElement(false); auto avail_elem = avail / per_elem; diff --git a/tests/cpp/common/test_hist_util.h b/tests/cpp/common/test_hist_util.h index ccfdbff52..7750e5ade 100644 --- a/tests/cpp/common/test_hist_util.h +++ b/tests/cpp/common/test_hist_util.h @@ -18,6 +18,9 @@ #ifdef __CUDACC__ #include #include "../../../src/data/device_adapter.cuh" +#elif defined(__HIP_PLATFORM_AMD__) +#include +#include "../../../src/data/device_adapter.hip.h" #endif // __CUDACC__ // Some helper functions used to test both GPU and CPU algorithms @@ -47,7 +50,7 @@ inline std::vector GenerateRandomWeights(int num_rows) { return w; } -#ifdef __CUDACC__ +#if defined(__CUDACC__) || defined(__HIP_PLATFORM_AMD__) inline data::CupyAdapter AdapterFromData(const thrust::device_vector &x, int num_rows, int num_columns) { Json array_interface{Object()}; diff --git a/tests/cpp/common/test_hist_util.hip b/tests/cpp/common/test_hist_util.hip index e69de29bb..625408b6f 100644 --- a/tests/cpp/common/test_hist_util.hip +++ b/tests/cpp/common/test_hist_util.hip @@ -0,0 +1,4 @@ + +#if defined(XGBOOST_USE_HIP) +#include "test_hist_util.cu" +#endif diff --git a/tests/cpp/common/test_host_device_vector.cu b/tests/cpp/common/test_host_device_vector.cu index ade2537f9..c67bf518e 100644 --- a/tests/cpp/common/test_host_device_vector.cu +++ b/tests/cpp/common/test_host_device_vector.cu @@ -6,7 +6,12 @@ #include #include +#if defined(XGBOOST_USE_CUDA) #include "../../../src/common/device_helpers.cuh" +#elif defined(XGBOOST_USE_HIP) +#include "../../../src/common/device_helpers.hip.h" +#endif + #include namespace xgboost { @@ -14,9 +19,16 @@ namespace common { namespace { void SetDeviceForTest(int device) { int n_devices; + +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaGetDeviceCount(&n_devices)); device %= n_devices; dh::safe_cuda(cudaSetDevice(device)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipGetDeviceCount(&n_devices)); + device %= n_devices; + dh::safe_cuda(hipSetDevice(device)); +#endif } } // namespace diff --git a/tests/cpp/common/test_host_device_vector.hip b/tests/cpp/common/test_host_device_vector.hip index e69de29bb..2fa76eb34 100644 --- a/tests/cpp/common/test_host_device_vector.hip +++ b/tests/cpp/common/test_host_device_vector.hip @@ -0,0 +1,4 @@ + +#if defined(XGBOOST_USE_HIP) +#include "test_host_device_vector.cu" +#endif diff --git a/tests/cpp/common/test_linalg.hip b/tests/cpp/common/test_linalg.hip index e69de29bb..5da9417bb 100644 --- a/tests/cpp/common/test_linalg.hip +++ b/tests/cpp/common/test_linalg.hip @@ -0,0 +1,2 @@ + +#include "test_linalg.cu" diff --git a/tests/cpp/common/test_quantile.cu b/tests/cpp/common/test_quantile.cu index f36334bcc..cdd2eb3ba 100644 --- a/tests/cpp/common/test_quantile.cu +++ b/tests/cpp/common/test_quantile.cu @@ -80,7 +80,11 @@ TEST(GPUQuantile, Unique) { // if with_error is true, the test tolerates floating point error void TestQuantileElemRank(int32_t device, Span in, Span d_columns_ptr, bool with_error = false) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(device)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(device)); +#endif std::vector h_in(in.size()); dh::CopyDeviceSpanToVector(&h_in, in); std::vector h_columns_ptr(d_columns_ptr.size()); diff --git a/tests/cpp/common/test_quantile.hip b/tests/cpp/common/test_quantile.hip index e69de29bb..abc7778ce 100644 --- a/tests/cpp/common/test_quantile.hip +++ b/tests/cpp/common/test_quantile.hip @@ -0,0 +1,2 @@ + +#include "test_quantile.cu" diff --git a/tests/cpp/common/test_span.cu b/tests/cpp/common/test_span.cu index 85c952340..afebcf91c 100644 --- a/tests/cpp/common/test_span.cu +++ b/tests/cpp/common/test_span.cu @@ -7,7 +7,12 @@ #include #include +#if defined(XGBOOST_USE_CUDA) #include "../../../src/common/device_helpers.cuh" +#elif defined(XGBOOST_USE_HIP) +#include "../../../src/common/device_helpers.hip.h" +#endif + #include #include "test_span.h" @@ -20,19 +25,37 @@ struct TestStatus { public: TestStatus () { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaMalloc(&status_, sizeof(int))); int h_status = 1; dh::safe_cuda(cudaMemcpy(status_, &h_status, sizeof(int), cudaMemcpyHostToDevice)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipMalloc(&status_, sizeof(int))); + int h_status = 1; + dh::safe_cuda(hipMemcpy(status_, &h_status, + sizeof(int), hipMemcpyHostToDevice)); +#endif } ~TestStatus() { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaFree(status_)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipFree(status_)); +#endif } int Get() { int h_status; + +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaMemcpy(&h_status, status_, sizeof(int), cudaMemcpyDeviceToHost)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipMemcpy(&h_status, status_, + sizeof(int), hipMemcpyDeviceToHost)); +#endif + return h_status; } @@ -89,14 +112,22 @@ TEST(GPUSpan, FromOther) { } TEST(GPUSpan, Assignment) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestAssignment{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpan, TestStatus) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestTestStatus{status.Data()}); ASSERT_EQ(status.Get(), -1); @@ -119,7 +150,11 @@ struct TestEqual { }; TEST(GPUSpan, WithTrust) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif // Not adviced to initialize span with host_vector, since h_vec.data() is // a host function. thrust::host_vector h_vec (16); @@ -156,14 +191,22 @@ TEST(GPUSpan, WithTrust) { } TEST(GPUSpan, BeginEnd) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestBeginEnd{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpan, RBeginREnd) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestRBeginREnd{status.Data()}); ASSERT_EQ(status.Get(), 1); @@ -195,14 +238,22 @@ TEST(GPUSpan, Modify) { } TEST(GPUSpan, Observers) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestObservers{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpan, Compare) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestIterCompare{status.Data()}); ASSERT_EQ(status.Get(), 1); @@ -222,7 +273,11 @@ struct TestElementAccess { }; TEST(GPUSpanDeathTest, ElementAccess) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif auto test_element_access = []() { thrust::host_vector h_vec (16); InitializeRange(h_vec.begin(), h_vec.end()); @@ -320,8 +375,13 @@ void TestFrontBack() { // make sure the termination happens inside this test. try { dh::LaunchN(1, [=] __device__(size_t) { s.front(); }); +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaDeviceSynchronize()); dh::safe_cuda(cudaGetLastError()); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipDeviceSynchronize()); + dh::safe_cuda(hipGetLastError()); +#endif } catch (dmlc::Error const& e) { std::terminate(); } @@ -331,8 +391,13 @@ void TestFrontBack() { { try { dh::LaunchN(1, [=] __device__(size_t) { s.back(); }); +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaDeviceSynchronize()); dh::safe_cuda(cudaGetLastError()); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipDeviceSynchronize()); + dh::safe_cuda(hipGetLastError()); +#endif } catch (dmlc::Error const& e) { std::terminate(); } @@ -382,42 +447,66 @@ TEST(GPUSpanDeathTest, Subspan) { } TEST(GPUSpanIter, Construct) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestIterConstruct{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpanIter, Ref) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestIterRef{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpanIter, Calculate) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestIterCalculate{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpanIter, Compare) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestIterCompare{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpan, AsBytes) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestAsBytes{status.Data()}); ASSERT_EQ(status.Get(), 1); } TEST(GPUSpan, AsWritableBytes) { +#if defined(XGBOOST_USE_CUDA) dh::safe_cuda(cudaSetDevice(0)); +#elif defined(XGBOOST_USE_HIP) + dh::safe_cuda(hipSetDevice(0)); +#endif TestStatus status; dh::LaunchN(16, TestAsWritableBytes{status.Data()}); ASSERT_EQ(status.Get(), 1); diff --git a/tests/cpp/common/test_span.hip b/tests/cpp/common/test_span.hip index e69de29bb..6efb375b0 100644 --- a/tests/cpp/common/test_span.hip +++ b/tests/cpp/common/test_span.hip @@ -0,0 +1,4 @@ + +#if defined(XGBOOST_USE_HIP) +#include "test_span.cu" +#endif diff --git a/tests/cpp/common/test_stats.cc b/tests/cpp/common/test_stats.cc index abdf00425..8b122a202 100644 --- a/tests/cpp/common/test_stats.cc +++ b/tests/cpp/common/test_stats.cc @@ -70,13 +70,13 @@ TEST(Stats, Median) { auto m = out(0); ASSERT_EQ(m, .5f); -#if defined(XGBOOST_USE_CUDA) +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) ctx.gpu_id = 0; ASSERT_FALSE(ctx.IsCPU()); Median(&ctx, values, weights, &out); m = out(0); ASSERT_EQ(m, .5f); -#endif // defined(XGBOOST_USE_CUDA) +#endif // defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) } { @@ -89,12 +89,12 @@ TEST(Stats, Median) { ASSERT_EQ(out(0), .5f); ASSERT_EQ(out(1), .5f); -#if defined(XGBOOST_USE_CUDA) +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) ctx.gpu_id = 0; Median(&ctx, values, weights, &out); ASSERT_EQ(out(0), .5f); ASSERT_EQ(out(1), .5f); -#endif // defined(XGBOOST_USE_CUDA) +#endif // defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) } } @@ -121,12 +121,12 @@ TEST(Stats, Mean) { TestMean(&ctx); } -#if defined(XGBOOST_USE_CUDA) +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) TEST(Stats, GPUMean) { Context ctx; ctx.UpdateAllowUnknown(Args{{"gpu_id", "0"}}); TestMean(&ctx); } -#endif // defined(XGBOOST_USE_CUDA) +#endif // defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) } // namespace common } // namespace xgboost diff --git a/tests/cpp/common/test_stats.hip b/tests/cpp/common/test_stats.hip index e69de29bb..994883218 100644 --- a/tests/cpp/common/test_stats.hip +++ b/tests/cpp/common/test_stats.hip @@ -0,0 +1,2 @@ + +#include "test_stats.cu" diff --git a/tests/cpp/common/test_threading_utils.hip b/tests/cpp/common/test_threading_utils.hip index e69de29bb..52c705a49 100644 --- a/tests/cpp/common/test_threading_utils.hip +++ b/tests/cpp/common/test_threading_utils.hip @@ -0,0 +1,2 @@ + +#include "test_threading_utils.cu" diff --git a/tests/cpp/common/test_transform_range.cc b/tests/cpp/common/test_transform_range.cc index 6e3ae9d82..396d9f307 100644 --- a/tests/cpp/common/test_transform_range.cc +++ b/tests/cpp/common/test_transform_range.cc @@ -11,7 +11,7 @@ #include "../../../src/common/transform.h" #include "../helpers.h" -#if defined(__CUDACC__) +#if defined(__CUDACC__) || defined(__HIP_PLATFORM_AMD__) #define TRANSFORM_GPU 0 @@ -53,7 +53,7 @@ TEST(Transform, DeclareUnifiedTest(Basic)) { ASSERT_TRUE(std::equal(h_sol.begin(), h_sol.end(), res.begin())); } -#if !defined(__CUDACC__) +#if !defined(__CUDACC__) && !defined(__HIP_PLATFORM_AMD__) TEST(TransformDeathTest, Exception) { size_t const kSize {16}; std::vector h_in(kSize); diff --git a/tests/cpp/gbm/test_gbtree.cc b/tests/cpp/gbm/test_gbtree.cc index c96b98497..c99adc06e 100644 --- a/tests/cpp/gbm/test_gbtree.cc +++ b/tests/cpp/gbm/test_gbtree.cc @@ -40,13 +40,13 @@ TEST(GBTree, SelectTreeMethod) { gbtree.Configure({{"booster", "dart"}, {"tree_method", "hist"}}); ASSERT_EQ(tparam.updater_seq, "grow_quantile_histmaker"); -#ifdef XGBOOST_USE_CUDA +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) ctx.UpdateAllowUnknown(Args{{"gpu_id", "0"}}); gbtree.Configure({{"tree_method", "gpu_hist"}}); ASSERT_EQ(tparam.updater_seq, "grow_gpu_hist"); gbtree.Configure({{"booster", "dart"}, {"tree_method", "gpu_hist"}}); ASSERT_EQ(tparam.updater_seq, "grow_gpu_hist"); -#endif // XGBOOST_USE_CUDA +#endif // XGBOOST_USE_CUDA, XGBOOST_USE_HIP } TEST(GBTree, PredictionCache) { @@ -110,7 +110,7 @@ TEST(GBTree, WrongUpdater) { ASSERT_THROW(learner->UpdateOneIter(0, p_dmat), dmlc::Error); } -#ifdef XGBOOST_USE_CUDA +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) TEST(GBTree, ChoosePredictor) { // The test ensures data don't get pulled into device. size_t constexpr kRows = 17; @@ -162,7 +162,7 @@ TEST(GBTree, ChoosePredictor) { // data is not pulled back into host ASSERT_FALSE(data.HostCanWrite()); } -#endif // XGBOOST_USE_CUDA +#endif // XGBOOST_USE_CUDA || XGBOOST_USE_HIP // Some other parts of test are in `Tree.JsonIO'. TEST(GBTree, JsonIO) { @@ -294,12 +294,12 @@ class Dart : public testing::TestWithParam { TEST_P(Dart, Prediction) { this->Run(GetParam()); } -#if defined(XGBOOST_USE_CUDA) +#if defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) INSTANTIATE_TEST_SUITE_P(PredictorTypes, Dart, testing::Values("auto", "cpu_predictor", "gpu_predictor")); #else INSTANTIATE_TEST_SUITE_P(PredictorTypes, Dart, testing::Values("auto", "cpu_predictor")); -#endif // defined(XGBOOST_USE_CUDA) +#endif // defined(XGBOOST_USE_CUDA) || defined(XGBOOST_USE_HIP) std::pair TestModelSlice(std::string booster) {