From 95977a6d45386add97afddb26bc8b8ab4a4a9f46 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Mon, 4 May 2020 12:25:06 +0100 Subject: [PATCH 1/7] Backend agnostic PI tests are parameterised by PI Plugin. Enable CUDA + OpenCL PI unit tests. Signed-off-by: Stuart Adams --- sycl/include/CL/sycl/detail/pi.h | 2 + sycl/plugins/cuda/pi_cuda.cpp | 9 +- sycl/unittests/pi/CMakeLists.txt | 2 +- sycl/unittests/pi/EnqueueMemTest.cpp | 49 ++++--- sycl/unittests/pi/EventTest.cpp | 129 ++++++++++-------- sycl/unittests/pi/PlatformTest.cpp | 29 ++-- sycl/unittests/pi/cuda/test_base_objects.cpp | 57 ++++---- sycl/unittests/pi/cuda/test_commands.cpp | 43 +++--- sycl/unittests/pi/cuda/test_device.cpp | 34 ++--- sycl/unittests/pi/cuda/test_events.cpp | 38 +++--- sycl/unittests/pi/cuda/test_get_plugin.hpp | 20 +++ .../pi/cuda/test_interop_get_native.cpp | 32 +++-- sycl/unittests/pi/cuda/test_kernels.cpp | 122 ++++++++--------- sycl/unittests/pi/cuda/test_mem_obj.cpp | 35 ++--- .../pi/cuda/test_primary_context.cpp | 9 +- sycl/unittests/pi/cuda/test_queue.cpp | 55 ++++---- 16 files changed, 369 insertions(+), 296 deletions(-) create mode 100644 sycl/unittests/pi/cuda/test_get_plugin.hpp diff --git a/sycl/include/CL/sycl/detail/pi.h b/sycl/include/CL/sycl/detail/pi.h index 49e569077f9fd..8848439dc0f22 100644 --- a/sycl/include/CL/sycl/detail/pi.h +++ b/sycl/include/CL/sycl/detail/pi.h @@ -132,6 +132,8 @@ typedef enum { // make the translation to OpenCL transparent. // typedef enum : pi_uint64 { + PI_DEVICE_TYPE_DEFAULT = CL_DEVICE_TYPE_DEFAULT, + PI_DEVICE_TYPE_ALL = CL_DEVICE_TYPE_ALL, PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU, PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR diff --git a/sycl/plugins/cuda/pi_cuda.cpp b/sycl/plugins/cuda/pi_cuda.cpp index af15743438da8..fb2addafafacf 100644 --- a/sycl/plugins/cuda/pi_cuda.cpp +++ b/sycl/plugins/cuda/pi_cuda.cpp @@ -716,15 +716,18 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type, pi_uint32 *num_devices) { pi_result err = PI_SUCCESS; - const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU); - size_t numDevices = askingForGPU ? platform->devices_.size() : 0; + const bool askingForDefault = device_type == PI_DEVICE_TYPE_DEFAULT; + const bool askingForGPU = device_type & PI_DEVICE_TYPE_GPU; + const bool returnDevices = askingForDefault || askingForGPU; + + size_t numDevices = returnDevices ? platform->devices_.size() : 0; try { if (num_devices) { *num_devices = numDevices; } - if (askingForGPU && devices) { + if (returnDevices && devices) { for (size_t i = 0; i < std::min(size_t(num_entries), numDevices); ++i) { devices[i] = platform->devices_[i].get(); } diff --git a/sycl/unittests/pi/CMakeLists.txt b/sycl/unittests/pi/CMakeLists.txt index 814f7da464508..fbaf61fea440f 100644 --- a/sycl/unittests/pi/CMakeLists.txt +++ b/sycl/unittests/pi/CMakeLists.txt @@ -2,7 +2,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) # Enable exception handling for these unit tests set(LLVM_REQUIRES_EH 1) -add_sycl_unittest(PiTests OBJECT +add_sycl_unittest(PiTests OBJECT EnqueueMemTest.cpp PiMock.cpp PlatformTest.cpp diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp index d8cbcee51eaeb..95b5a654daaaa 100644 --- a/sycl/unittests/pi/EnqueueMemTest.cpp +++ b/sycl/unittests/pi/EnqueueMemTest.cpp @@ -13,10 +13,8 @@ using namespace cl::sycl; namespace { -class DISABLED_EnqueueMemTest : public ::testing::Test { +class EnqueueMemTest : public testing::TestWithParam { protected: - std::vector Plugins; - constexpr static size_t _numElementsX = 8; constexpr static size_t _numElementsY = 4; @@ -25,51 +23,56 @@ class DISABLED_EnqueueMemTest : public ::testing::Test { pi_queue _queue = nullptr; pi_mem _mem = nullptr; - DISABLED_EnqueueMemTest() = default; + EnqueueMemTest() = default; - ~DISABLED_EnqueueMemTest() = default; + ~EnqueueMemTest() = default; void SetUp() override { - Plugins = detail::pi::initialize(); - ASSERT_FALSE(Plugins.empty()); + + detail::plugin plugin = GetParam(); pi_platform platform = nullptr; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 1, &platform, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( - platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), + ASSERT_EQ((plugin.call_nocheck( + platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)), PI_SUCCESS); pi_result result = PI_INVALID_VALUE; - result = Plugins[0].call_nocheck( + result = plugin.call_nocheck( nullptr, 1u, &_device, nullptr, nullptr, &_context); ASSERT_EQ(result, PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32), nullptr, &_mem)), PI_SUCCESS); } void TearDown() override { - ASSERT_EQ((Plugins[0].call_nocheck(_mem)), + + detail::plugin plugin = GetParam(); + + ASSERT_EQ((plugin.call_nocheck(_mem)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck(_queue)), + (plugin.call_nocheck(_queue)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context)), PI_SUCCESS); } template void TestBufferFill(const T &pattern) { + detail::plugin plugin = GetParam(); + T inValues[_numElementsX] = {}; for (size_t i = 0; i < _numElementsX; ++i) { @@ -77,20 +80,20 @@ class DISABLED_EnqueueMemTest : public ::testing::Test { } ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0, nullptr, nullptr)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr, nullptr)), PI_SUCCESS); T outValues[_numElementsX] = {}; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0, nullptr, nullptr)), PI_SUCCESS); @@ -101,6 +104,12 @@ class DISABLED_EnqueueMemTest : public ::testing::Test { } }; +static std::vector Plugins = detail::pi::initialize(); + +INSTANTIATE_TEST_CASE_P(EnqueueMemTestImpl, + EnqueueMemTest, + testing::ValuesIn(Plugins),); + template struct vec4 { T x, y, z, w; @@ -127,7 +136,7 @@ struct vec2 { } }; -TEST_F(DISABLED_EnqueueMemTest, piEnqueueMemBufferFill) { +TEST_P(EnqueueMemTest, piEnqueueMemBufferFill) { TestBufferFill(float{1}); TestBufferFill(vec2{1, 2}); diff --git a/sycl/unittests/pi/EventTest.cpp b/sycl/unittests/pi/EventTest.cpp index d3c88b9db97a7..c824ac24a96a3 100644 --- a/sycl/unittests/pi/EventTest.cpp +++ b/sycl/unittests/pi/EventTest.cpp @@ -15,48 +15,46 @@ using namespace cl::sycl; namespace pi { -class DISABLED_EventTest : public ::testing::Test { +class EventTest : public testing::TestWithParam { protected: - std::vector Plugins; - pi_platform _platform; pi_context _context; pi_queue _queue; pi_device _device; pi_result _result; - DISABLED_EventTest() + EventTest() : _context{nullptr}, _queue{nullptr}, _device{nullptr}, _result{PI_INVALID_VALUE} { - Plugins = detail::pi::initialize(); } - ~DISABLED_EventTest() override = default; + ~EventTest() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((Plugins[0].call_nocheck( + detail::plugin plugin = GetParam(); + + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &_platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; (void)numPlatforms; // Deal with unused variable warning - ASSERT_EQ((Plugins[0].call_nocheck( - _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), + ASSERT_EQ((plugin.call_nocheck( + _platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); @@ -65,27 +63,38 @@ class DISABLED_EventTest : public ::testing::Test { void TearDown() override { + detail::plugin plugin = GetParam(); + ASSERT_EQ( - (Plugins[0].call_nocheck(_queue)), + (plugin.call_nocheck(_queue)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context)), PI_SUCCESS); } }; +static std::vector Plugins = detail::pi::initialize(); + +INSTANTIATE_TEST_CASE_P(EventTestImpl, + EventTest, + testing::ValuesIn(Plugins),); + // TODO: need more negative tests to show errors being reported when expected // (invalid arguments etc). -TEST_F(DISABLED_EventTest, PICreateEvent) { +TEST_P(EventTest, PICreateEvent) { pi_event foo; - ASSERT_EQ((Plugins[0].call_nocheck(_context, + + detail::plugin plugin = GetParam(); + + ASSERT_EQ((plugin.call_nocheck(_context, &foo)), PI_SUCCESS); ASSERT_NE(foo, nullptr); - EXPECT_EQ((Plugins[0].call_nocheck(foo)), + EXPECT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } @@ -110,7 +119,9 @@ void EventCallback(pi_event event, pi_int32 status, void *data) { triggered_flag[pdata->index] = true; } -TEST_F(DISABLED_EventTest, piEventSetCallback) { +TEST_P(EventTest, piEventSetCallback) { + + detail::plugin plugin = GetParam(); pi_int32 event_callback_types[event_type_count] = { PI_EVENT_SUBMITTED, PI_EVENT_RUNNING, PI_EVENT_COMPLETE}; @@ -120,7 +131,7 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) { // gate event lets us register callbacks before letting the enqueued work be // executed. pi_event gateEvent; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, &gateEvent)), PI_SUCCESS); @@ -130,13 +141,13 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) { pi_mem memObj; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _context, PI_MEM_FLAGS_ACCESS_RW, size_in_bytes, nullptr, &memObj)), PI_SUCCESS); pi_event syncEvent; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, memObj, false, 0, size_in_bytes, data.data(), 1, &gateEvent, &syncEvent)), PI_SUCCESS); @@ -145,18 +156,18 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) { user_data[i].event_type = event_callback_types[i]; user_data[i].index = i; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( syncEvent, event_callback_types[i], EventCallback, user_data + i)), PI_SUCCESS); } - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( gateEvent, PI_EVENT_COMPLETE)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck(1, &syncEvent)), + (plugin.call_nocheck(1, &syncEvent)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(_queue)), + ASSERT_EQ((plugin.call_nocheck(_queue)), PI_SUCCESS); for (size_t k = 0; k < event_type_count; ++k) { @@ -164,24 +175,26 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) { } ASSERT_EQ( - (Plugins[0].call_nocheck(gateEvent)), + (plugin.call_nocheck(gateEvent)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck(syncEvent)), + (plugin.call_nocheck(syncEvent)), PI_SUCCESS); } -TEST_F(DISABLED_EventTest, piEventGetInfo) { +TEST_P(EventTest, piEventGetInfo) { + + detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((Plugins[0].call_nocheck(_context, + ASSERT_EQ((plugin.call_nocheck(_context, &foo)), PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_uint64 paramValue = 0; pi_uint64 retSize = 0; - EXPECT_EQ((Plugins[0].call_nocheck( + EXPECT_EQ((plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -189,51 +202,55 @@ TEST_F(DISABLED_EventTest, piEventGetInfo) { EXPECT_EQ(retSize, sizeof(pi_int32)); EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED); - EXPECT_EQ((Plugins[0].call_nocheck(foo)), + EXPECT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } -TEST_F(DISABLED_EventTest, piEventSetStatus) { +TEST_P(EventTest, piEventSetStatus) { + + detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((Plugins[0].call_nocheck(_context, + ASSERT_EQ((plugin.call_nocheck(_context, &foo)), PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = PI_EVENT_QUEUED; size_t retSize = 0u; - Plugins[0].call_nocheck( + plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize); - EXPECT_EQ((Plugins[0].call_nocheck( + EXPECT_EQ((plugin.call_nocheck( foo, PI_EVENT_COMPLETE)), PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_COMPLETE); - EXPECT_EQ((Plugins[0].call_nocheck(foo)), + EXPECT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } -TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) { +TEST_P(EventTest, WaitForManualEventOnOtherThread) { + + detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((Plugins[0].call_nocheck(_context, + ASSERT_EQ((plugin.call_nocheck(_context, &foo)), PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -244,14 +261,14 @@ TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) { auto tWaiter = std::thread([&]() { started = true; ASSERT_EQ( - (Plugins[0].call_nocheck(1, &foo)), + (plugin.call_nocheck(1, &foo)), PI_SUCCESS); }); while (!started) { }; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( foo, PI_EVENT_COMPLETE)), PI_SUCCESS); @@ -259,17 +276,19 @@ TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) { paramValue = {}; retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_COMPLETE); - ASSERT_EQ((Plugins[0].call_nocheck(foo)), + ASSERT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } -TEST_F(DISABLED_EventTest, piEnqueueEventsWait) { +TEST_P(EventTest, piEnqueueEventsWait) { + + detail::plugin plugin = GetParam(); constexpr const size_t dataCount = 10u; int output[dataCount] = {}; @@ -277,53 +296,53 @@ TEST_F(DISABLED_EventTest, piEnqueueEventsWait) { constexpr const size_t bytes = sizeof(data); pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); pi_event events[4] = {nullptr, nullptr, nullptr, nullptr}; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])), PI_SUCCESS); ASSERT_NE(events[0], nullptr); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( _queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])), PI_SUCCESS); ASSERT_NE(events[1], nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, &events[2])), PI_SUCCESS); ASSERT_NE(events[2], nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _queue, 3, events, &events[3])), PI_SUCCESS); ASSERT_NE(events[3], nullptr); pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_NE(paramValue, PI_EVENT_COMPLETE); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( events[2], PI_EVENT_COMPLETE)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck(1, &events[3])), + (plugin.call_nocheck(1, &events[3])), PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp index f04f6dea2de09..fdc5cdb68f1c3 100644 --- a/sycl/unittests/pi/PlatformTest.cpp +++ b/sycl/unittests/pi/PlatformTest.cpp @@ -16,15 +16,17 @@ namespace { using namespace cl::sycl; -class PlatformTest : public ::testing::Test { +class PlatformTest : public testing::TestWithParam { protected: std::vector _platforms; - std::vector Plugins; - PlatformTest() : _platforms{} { Plugins = detail::pi::initialize(); }; + PlatformTest() : _platforms{} {}; ~PlatformTest() override = default; void SetUp() { + + detail::plugin plugin = GetParam(); + ASSERT_NO_FATAL_FAILURE(Test::SetUp()); const static char *platform_count_key = "PiPlatformCount"; @@ -36,7 +38,7 @@ class PlatformTest : public ::testing::Test { // TODO: Change the test to check this for all plugins present. // Currently, it is only checking for the first plugin attached. - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &platform_count)), PI_SUCCESS); @@ -54,28 +56,37 @@ class PlatformTest : public ::testing::Test { _platforms.resize(platform_count, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _platforms.size(), _platforms.data(), nullptr)), PI_SUCCESS); } }; -TEST_F(PlatformTest, piPlatformsGet) { +static std::vector Plugins = detail::pi::initialize(); + +INSTANTIATE_TEST_CASE_P(PlatformTestImpl, + PlatformTest, + testing::ValuesIn(Plugins),); + +TEST_P(PlatformTest, piPlatformsGet) { // The PlatformTest::SetUp method is called to prepare for this test case // implicitly tests the calls to `piPlatformsGet`. } -TEST_F(PlatformTest, piPlatformGetInfo) { +TEST_P(PlatformTest, piPlatformGetInfo) { + + detail::plugin plugin = GetParam(); + auto get_info_test = [&](pi_platform platform, _pi_platform_info info) { size_t reported_string_length = 0; - EXPECT_EQ((Plugins[0].call_nocheck( + EXPECT_EQ((plugin.call_nocheck( platform, info, 0u, nullptr, &reported_string_length)), PI_SUCCESS); // Create a larger result string to catch overwrites. std::vector param_value(reported_string_length * 2u, '\0'); EXPECT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( platform, info, param_value.size(), param_value.data(), nullptr)), PI_SUCCESS) << "piPlatformGetInfo for " << detail::pi::platformInfoToString(info) diff --git a/sycl/unittests/pi/cuda/test_base_objects.cpp b/sycl/unittests/pi/cuda/test_base_objects.cpp index 34c361a5c43f1..4ca4569351dd8 100644 --- a/sycl/unittests/pi/cuda/test_base_objects.cpp +++ b/sycl/unittests/pi/cuda/test_base_objects.cpp @@ -16,32 +16,33 @@ #include #include #include +#include "test_get_plugin.hpp" const unsigned int LATEST_KNOWN_CUDA_DRIVER_API_VERSION = 3020u; using namespace cl::sycl; -class DISABLED_CudaBaseObjectsTest : public ::testing::Test { +class CudaBaseObjectsTest : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); - DISABLED_CudaBaseObjectsTest() { Plugins = detail::pi::initialize(); } + CudaBaseObjectsTest() = default; - ~DISABLED_CudaBaseObjectsTest() = default; + ~CudaBaseObjectsTest() = default; }; -TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) { +TEST_F(CudaBaseObjectsTest, piContextCreate) { pi_uint32 numPlatforms = 0; pi_platform platform = nullptr; pi_device device; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; @@ -49,13 +50,13 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) { ASSERT_GE(numPlatforms, 1u); ASSERT_NE(platform, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS) << "piDevicesGet failed.\n"; pi_context ctxt = nullptr; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS) << "piContextCreate failed.\n"; @@ -73,29 +74,29 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) { ASSERT_EQ(cuErr, CUDA_SUCCESS); } -TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryTrue) { +TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); pi_context_properties properties[] = {PI_CONTEXT_PROPERTIES_CUDA_PRIMARY, PI_TRUE, 0}; pi_context ctxt; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( properties, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -115,33 +116,33 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryTrue) { ASSERT_EQ(cuErr, CUDA_SUCCESS); ASSERT_EQ(current, cudaContext); ASSERT_EQ( - (Plugins[0].call_nocheck(ctxt)), + (plugin.call_nocheck(ctxt)), PI_SUCCESS); } -TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryFalse) { +TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); pi_context_properties properties[] = {PI_CONTEXT_PROPERTIES_CUDA_PRIMARY, PI_FALSE, 0}; pi_context ctxt; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( properties, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -161,31 +162,31 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryFalse) { ASSERT_EQ(cuErr, CUDA_SUCCESS); ASSERT_EQ(current, cudaContext); ASSERT_EQ( - (Plugins[0].call_nocheck(ctxt)), + (plugin.call_nocheck(ctxt)), PI_SUCCESS); } -TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { +TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); pi_context ctxt; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -217,6 +218,6 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { callContextFromOtherThread.join(); ASSERT_EQ( - (Plugins[0].call_nocheck(ctxt)), + (plugin.call_nocheck(ctxt)), PI_SUCCESS); } diff --git a/sycl/unittests/pi/cuda/test_commands.cpp b/sycl/unittests/pi/cuda/test_commands.cpp index cce61e9fdd418..cea812a434c02 100644 --- a/sycl/unittests/pi/cuda/test_commands.cpp +++ b/sycl/unittests/pi/cuda/test_commands.cpp @@ -14,13 +14,14 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; -struct DISABLED_CudaCommandsTest : public ::testing::Test { +struct CudaCommandsTest : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform platform_; pi_device device_; @@ -30,27 +31,27 @@ struct DISABLED_CudaCommandsTest : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, 0, &queue_)), PI_SUCCESS); ASSERT_NE(queue_, nullptr); @@ -59,32 +60,32 @@ struct DISABLED_CudaCommandsTest : public ::testing::Test { } void TearDown() override { - Plugins[0].call(queue_); - Plugins[0].call(context_); + plugin.call(queue_); + plugin.call(context_); } - DISABLED_CudaCommandsTest() { Plugins = detail::pi::initialize(); } + CudaCommandsTest() = default; - ~DISABLED_CudaCommandsTest() = default; + ~CudaCommandsTest() = default; }; -TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferBlocking) { +TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) { constexpr const size_t memSize = 10u; constexpr const size_t bytes = memSize * sizeof(int); const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int output[memSize] = {}; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)), PI_SUCCESS); @@ -98,31 +99,31 @@ TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferBlocking) { } } -TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { +TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { constexpr const size_t memSize = 10u; constexpr const size_t bytes = memSize * sizeof(int); const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int output[memSize] = {}; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); pi_event cpIn, cpOut; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)), PI_SUCCESS); ASSERT_NE(cpIn, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( queue_, memObj, false, 0, bytes, output, 0, nullptr, &cpOut)), PI_SUCCESS); ASSERT_NE(cpOut, nullptr); ASSERT_EQ( - (Plugins[0].call_nocheck(1, &cpOut)), + (plugin.call_nocheck(1, &cpOut)), PI_SUCCESS); bool isSame = diff --git a/sycl/unittests/pi/cuda/test_device.cpp b/sycl/unittests/pi/cuda/test_device.cpp index d4f9e2bb01939..5f3d3a61146db 100644 --- a/sycl/unittests/pi/cuda/test_device.cpp +++ b/sycl/unittests/pi/cuda/test_device.cpp @@ -14,13 +14,14 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; -struct DISABLED_CudaDeviceTests : public ::testing::Test { +struct CudaDeviceTests : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform platform_; pi_device device_; @@ -28,42 +29,41 @@ struct DISABLED_CudaDeviceTests : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - Plugins[0].call(device_); - Plugins[0].call(context_); + plugin.call(device_); + plugin.call(context_); } - DISABLED_CudaDeviceTests() { detail::pi::initialize(); } - - ~DISABLED_CudaDeviceTests() = default; + CudaDeviceTests() = default; + ~CudaDeviceTests() = default; }; -TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { +TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) { size_t return_size = 0; pi_device_type device_type; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( device_, PI_DEVICE_INFO_TYPE, sizeof(pi_device_type), &device_type, &return_size)), PI_SUCCESS); @@ -73,7 +73,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { PI_DEVICE_TYPE_GPU); // backend pre-defined value, device must be a GPU pi_device parent_device = nullptr; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( device_, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(pi_device), &parent_device, &return_size)), PI_SUCCESS); @@ -82,7 +82,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { nullptr); // backend pre-set value, device cannot have a parent pi_platform platform = nullptr; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( device_, PI_DEVICE_INFO_PLATFORM, sizeof(pi_platform), &platform, &return_size)), PI_SUCCESS); @@ -91,7 +91,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { // test fixture platform cl_device_partition_property device_partition_property = -1; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( device_, PI_DEVICE_INFO_PARTITION_TYPE, sizeof(cl_device_partition_property), &device_partition_property, &return_size)), diff --git a/sycl/unittests/pi/cuda/test_events.cpp b/sycl/unittests/pi/cuda/test_events.cpp index e853cdd1c47c7..1d87b338fc52d 100644 --- a/sycl/unittests/pi/cuda/test_events.cpp +++ b/sycl/unittests/pi/cuda/test_events.cpp @@ -15,80 +15,80 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; namespace pi { -class DISABLED_CudaEventTests : public ::testing::Test { +class CudaEventTests : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform _platform; pi_context _context; pi_queue _queue; pi_device _device; - DISABLED_CudaEventTests() + CudaEventTests() : _context{nullptr}, _queue{nullptr}, _device{nullptr} { - Plugins = detail::pi::initialize(); } - ~DISABLED_CudaEventTests() override = default; + ~CudaEventTests() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &_platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); } void TearDown() override { - Plugins[0].call(_queue); - Plugins[0].call(_context); + plugin.call(_queue); + plugin.call(_context); } }; -TEST_F(DISABLED_CudaEventTests, PICreateEvent) { +TEST_F(CudaEventTests, PICreateEvent) { pi_event foo; - ASSERT_EQ((Plugins[0].call_nocheck(_context, + ASSERT_EQ((plugin.call_nocheck(_context, &foo)), PI_SUCCESS); ASSERT_NE(foo, nullptr); // There is no CUDA interop event for user events EXPECT_EQ(foo->get(), nullptr); - ASSERT_EQ((Plugins[0].call_nocheck(foo)), + ASSERT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } -TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) { +TEST_F(CudaEventTests, piGetInfoNativeEvent) { auto foo = _pi_event::make_native(PI_COMMAND_TYPE_NDRANGE_KERNEL, _queue); ASSERT_NE(foo, nullptr); pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -101,7 +101,7 @@ TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) { auto errCode = cuEventQuery(cuEvent); ASSERT_EQ(errCode, CUDA_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(foo)), + ASSERT_EQ((plugin.call_nocheck(foo)), PI_SUCCESS); } } // namespace pi diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp new file mode 100644 index 0000000000000..e73acd95f2184 --- /dev/null +++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include +#include + +using namespace cl::sycl; + +namespace pi { +inline detail::plugin initializeAndGetCuda() { + auto plugins = detail::pi::initialize(); + auto it = std::find_if(plugins.begin(), plugins.end(), + [](detail::plugin p) -> bool { return p.getBackend() == backend::cuda; }); + if(it == plugins.end()) { + throw std::runtime_error("PI CUDA plugin not found."); + } + return *it; +} +} \ No newline at end of file diff --git a/sycl/unittests/pi/cuda/test_interop_get_native.cpp b/sycl/unittests/pi/cuda/test_interop_get_native.cpp index 1aec0b4c26ab0..a2a7e040e614a 100644 --- a/sycl/unittests/pi/cuda/test_interop_get_native.cpp +++ b/sycl/unittests/pi/cuda/test_interop_get_native.cpp @@ -15,39 +15,43 @@ using namespace cl::sycl; -struct DISABLED_CudaInteropGetNativeTests : public ::testing::Test { +struct CudaInteropGetNativeTests : public ::testing::Test { protected: queue syclQueue_; context syclContext_; device syclDevice_; + CudaInteropGetNativeTests() + : syclQueue_(cuda_device_selector()) + , syclContext_(syclQueue_.get_context()) + , syclDevice_(syclQueue_.get_device()) + {} + static bool isCudaDevice(const device &dev) { const platform platform = dev.get_info(); const std::string platformVersion = platform.get_info(); + const std::string platformName = + platform.get_info(); // If using PI_CUDA, don't accept a non-CUDA device - return platformVersion.find("CUDA") != std::string::npos; + return platformVersion.find("CUDA") != std::string::npos && + platformName.find("NVIDIA CUDA") != std::string::npos; } class cuda_device_selector : public device_selector { public: int operator()(const device &dev) const { - return isCudaDevice(dev) ? 1 : -1; + return isCudaDevice(dev) ? 1000 : -1000; } }; - void SetUp() override { - syclQueue_ = queue{cuda_device_selector()}; - context syclContext_ = syclQueue_.get_context(); - device syclDevice_ = syclQueue_.get_device(); - ASSERT_TRUE(isCudaDevice(syclDevice_)); - } + void SetUp() override {} void TearDown() override {} }; -TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeDevice) { +TEST_F(CudaInteropGetNativeTests, getNativeDevice) { CUdevice cudaDevice = get_native(syclDevice_); char cudaDeviceName[2] = {0, 0}; CUresult result = cuDeviceGetName(cudaDeviceName, 2, cudaDevice); @@ -55,12 +59,12 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeDevice) { ASSERT_NE(cudaDeviceName[0], 0); } -TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeContext) { +TEST_F(CudaInteropGetNativeTests, getNativeContext) { CUcontext cudaContext = get_native(syclContext_); ASSERT_NE(cudaContext, nullptr); } -TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeQueue) { +TEST_F(CudaInteropGetNativeTests, getNativeQueue) { CUstream cudaStream = get_native(syclQueue_); ASSERT_NE(cudaStream, nullptr); @@ -72,7 +76,7 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeQueue) { ASSERT_EQ(streamContext, cudaContext); } -TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetMem) { +TEST_F(CudaInteropGetNativeTests, interopTaskGetMem) { buffer syclBuffer(range<1>{1}); syclQueue_.submit([&](cl::sycl::handler &cgh) { auto syclAccessor = syclBuffer.get_access(cgh); @@ -86,7 +90,7 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetMem) { }); } -TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetBufferMem) { +TEST_F(CudaInteropGetNativeTests, interopTaskGetBufferMem) { CUstream cudaStream = get_native(syclQueue_); syclQueue_.submit([&](cl::sycl::handler &cgh) { cgh.interop_task([=](sycl::interop_handler ih) { diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp index 7f302f532c708..53218261cf1e9 100644 --- a/sycl/unittests/pi/cuda/test_kernels.cpp +++ b/sycl/unittests/pi/cuda/test_kernels.cpp @@ -14,14 +14,14 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; -struct DISABLED_CudaKernelsTest : public ::testing::Test { +struct CudaKernelsTest : public ::testing::Test { protected: - std::vector Plugins; - + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform platform_; pi_device device_; pi_context context_; @@ -29,27 +29,27 @@ struct DISABLED_CudaKernelsTest : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, 0, &queue_)), PI_SUCCESS); ASSERT_NE(queue_, nullptr); @@ -57,14 +57,14 @@ struct DISABLED_CudaKernelsTest : public ::testing::Test { } void TearDown() override { - Plugins[0].call(device_); - Plugins[0].call(queue_); - Plugins[0].call(context_); + plugin.call(device_); + plugin.call(queue_); + plugin.call(context_); } - DISABLED_CudaKernelsTest() { Plugins = detail::pi::initialize(); } + CudaKernelsTest() = default; - ~DISABLED_CudaKernelsTest() = default; + ~CudaKernelsTest() = default; }; const char *ptxSource = "\n\ @@ -127,44 +127,44 @@ const char *threeParamsTwoLocal = "\n\ -TEST_F(DISABLED_CudaKernelsTest, PICreateProgramAndKernel) { +TEST_F(CudaKernelsTest, PICreateProgramAndKernel) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); ASSERT_NE(kern, nullptr); } -TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) { +TEST_F(CudaKernelsTest, PIKernelArgumentSimple) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -173,25 +173,25 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) { ASSERT_EQ(storedValue, number); } -TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { +TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -200,7 +200,7 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { ASSERT_EQ(storedValue, number); int otherNumber = 934; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 0, sizeof(int), &otherNumber)), PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); @@ -209,30 +209,30 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { ASSERT_EQ(storedValue, otherNumber); } -TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) { +TEST_F(CudaKernelsTest, PIKernelSetMemObj) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 0, sizeof(pi_mem), &memObj)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -241,31 +241,31 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) { ASSERT_EQ(storedValue, memObj); } -TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatch) { +TEST_F(CudaKernelsTest, PIkerneldispatch) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( kern, 0, &memObj)), PI_SUCCESS); @@ -273,50 +273,50 @@ TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatch) { size_t globalWorkOffset[] = {0}; size_t globalWorkSize[] = {1}; size_t localWorkSize[] = {1}; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( queue_, kern, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + ASSERT_EQ((plugin.call_nocheck(memObj)), PI_SUCCESS); } -TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) { +TEST_F(CudaKernelsTest, PIkerneldispatchTwo) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&twoParams, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "twoParamKernel", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); pi_mem memObj2; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( kern, 0, &memObj)), PI_SUCCESS); ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( kern, 1, &memObj2)), PI_SUCCESS); @@ -324,38 +324,38 @@ TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) { size_t globalWorkOffset[] = {0}; size_t globalWorkSize[] = {1}; size_t localWorkSize[] = {1}; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( queue_, kern, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + ASSERT_EQ((plugin.call_nocheck(memObj)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(memObj2)), + ASSERT_EQ((plugin.call_nocheck(memObj2)), PI_SUCCESS); } -TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { +TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { pi_program prog; ASSERT_EQ( - (Plugins[0].call_nocheck( + (plugin.call_nocheck( context_, 1, (const char **)&threeParamsTwoLocal, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( prog, "twoParamKernelLocal", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -363,7 +363,7 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { int storedValue = *(static_cast(kernArgs[0])); ASSERT_EQ(storedValue, number); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 1, sizeof(int), nullptr)), PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); @@ -371,7 +371,7 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { storedValue = *(static_cast(kernArgs2[1])); ASSERT_EQ(storedValue, 0); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( kern, 2, sizeof(int), nullptr)), PI_SUCCESS); const auto &kernArgs3 = kern->get_arg_indices(); diff --git a/sycl/unittests/pi/cuda/test_mem_obj.cpp b/sycl/unittests/pi/cuda/test_mem_obj.cpp index 8adf994ae2bdc..8996ecec501d5 100644 --- a/sycl/unittests/pi/cuda/test_mem_obj.cpp +++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp @@ -15,13 +15,14 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; -struct DISABLED_CudaTestMemObj : public ::testing::Test { +struct CudaTestMemObj : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform platform_; pi_device device_; @@ -30,49 +31,49 @@ struct DISABLED_CudaTestMemObj : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - Plugins[0].call(device_); - Plugins[0].call(context_); + plugin.call(device_); + plugin.call(context_); } - DISABLED_CudaTestMemObj() { Plugins = detail::pi::initialize(); } + CudaTestMemObj() = default; - ~DISABLED_CudaTestMemObj() = default; + ~CudaTestMemObj() = default; }; -TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateSimple) { +TEST_F(CudaTestMemObj, piMemBufferCreateSimple) { const size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + ASSERT_EQ((plugin.call_nocheck(memObj)), PI_SUCCESS); } -TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateNoActiveContext) { +TEST_F(CudaTestMemObj, piMemBufferCreateNoActiveContext) { const size_t memSize = 1024u; // Context has been destroyed @@ -92,11 +93,11 @@ TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateNoActiveContext) { // The context object is passed, even if its not active it should be used // to allocate the memory object pi_mem memObj; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); ASSERT_NE(memObj, nullptr); - ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + ASSERT_EQ((plugin.call_nocheck(memObj)), PI_SUCCESS); } diff --git a/sycl/unittests/pi/cuda/test_primary_context.cpp b/sycl/unittests/pi/cuda/test_primary_context.cpp index 8e387cb4a2536..a34d3491b6358 100644 --- a/sycl/unittests/pi/cuda/test_primary_context.cpp +++ b/sycl/unittests/pi/cuda/test_primary_context.cpp @@ -14,12 +14,13 @@ #include #include #include +#include "test_get_plugin.hpp" #include using namespace cl::sycl; -struct DISABLED_CudaPrimaryContextTests : public ::testing::Test { +struct CudaPrimaryContextTests : public ::testing::Test { protected: device deviceA_; @@ -77,7 +78,7 @@ struct DISABLED_CudaPrimaryContextTests : public ::testing::Test { void TearDown() override {} }; -TEST_F(DISABLED_CudaPrimaryContextTests, piSingleContext) { +TEST_F(CudaPrimaryContextTests, piSingleContext) { std::cout << "create single context" << std::endl; context Context(deviceA_, async_handler{}, /*UsePrimaryContext=*/true); @@ -92,7 +93,7 @@ TEST_F(DISABLED_CudaPrimaryContextTests, piSingleContext) { cuDevicePrimaryCtxRelease(CudaDevice); } -TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextSingleDevice) { +TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) { std::cout << "create multiple contexts for one device" << std::endl; context ContextA(deviceA_, async_handler{}, /*UsePrimaryContext=*/true); context ContextB(deviceA_, async_handler{}, /*UsePrimaryContext=*/true); @@ -103,7 +104,7 @@ TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextSingleDevice) { ASSERT_EQ(CudaContextA, CudaContextB); } -TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextMultiDevice) { +TEST_F(CudaPrimaryContextTests, piMultiContextMultiDevice) { CUdevice CudaDeviceA = deviceA_.get_native(); CUdevice CudaDeviceB = deviceB_.get_native(); diff --git a/sycl/unittests/pi/cuda/test_queue.cpp b/sycl/unittests/pi/cuda/test_queue.cpp index ca983e4c55c79..da5ae818d484f 100644 --- a/sycl/unittests/pi/cuda/test_queue.cpp +++ b/sycl/unittests/pi/cuda/test_queue.cpp @@ -15,13 +15,14 @@ #include #include #include +#include "test_get_plugin.hpp" using namespace cl::sycl; -struct DISABLED_CudaTestQueue : public ::testing::Test { +struct CudaTestQueue : public ::testing::Test { protected: - std::vector Plugins; + detail::plugin plugin = pi::initializeAndGetCuda(); pi_platform platform_; pi_device device_; @@ -29,40 +30,40 @@ struct DISABLED_CudaTestQueue : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_FALSE(Plugins.empty()); + ASSERT_EQ(plugin.getBackend(), backend::cuda); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - Plugins[0].call(device_); - Plugins[0].call(context_); + plugin.call(device_); + plugin.call(context_); } - DISABLED_CudaTestQueue() { detail::pi::initialize(); } + CudaTestQueue() = default; - ~DISABLED_CudaTestQueue() = default; + ~CudaTestQueue() = default; }; -TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) { +TEST_F(CudaTestQueue, PICreateQueueSimple) { pi_queue queue; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -73,13 +74,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); } -TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) { +TEST_F(CudaTestQueue, PIQueueFinishSimple) { pi_queue queue; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -87,18 +88,18 @@ TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) { // todo: post work on queue, ensure the results are valid and the work is // complete after piQueueFinish? - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); ASSERT_EQ(cuStreamQuery(queue->get()), CUDA_SUCCESS); - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); } -TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) { +TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) { pi_queue queue; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, PI_CUDA_USE_DEFAULT_STREAM, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -109,13 +110,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_DEFAULT); - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); } -TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) { +TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) { pi_queue queue; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, PI_CUDA_SYNC_WITH_DEFAULT, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -126,13 +127,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) { cuStreamGetFlags(stream, &flags); ASSERT_NE(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); } -TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) { +TEST_F(CudaTestQueue, PICreateQueueInterop) { pi_queue queue; - ASSERT_EQ((Plugins[0].call_nocheck( + ASSERT_EQ((plugin.call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -145,6 +146,6 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) { ASSERT_EQ(res, CUDA_SUCCESS); EXPECT_EQ(cuCtx, context_->get()); - ASSERT_EQ((Plugins[0].call_nocheck(queue)), + ASSERT_EQ((plugin.call_nocheck(queue)), PI_SUCCESS); } From 512741dd4848af24c7796967804db39fe4e0efcf Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Thu, 7 May 2020 13:19:16 +0100 Subject: [PATCH 2/7] Clang format Signed-off-by: Stuart Adams --- sycl/unittests/pi/EnqueueMemTest.cpp | 81 ++++++++----------- sycl/unittests/pi/EventTest.cpp | 81 +++++++++---------- sycl/unittests/pi/PlatformTest.cpp | 8 +- sycl/unittests/pi/cuda/test_base_objects.cpp | 17 ++-- sycl/unittests/pi/cuda/test_commands.cpp | 21 +++-- sycl/unittests/pi/cuda/test_device.cpp | 2 +- sycl/unittests/pi/cuda/test_events.cpp | 12 ++- sycl/unittests/pi/cuda/test_get_plugin.hpp | 13 +-- .../pi/cuda/test_interop_get_native.cpp | 10 +-- sycl/unittests/pi/cuda/test_kernels.cpp | 28 +++---- sycl/unittests/pi/cuda/test_mem_obj.cpp | 2 +- .../pi/cuda/test_primary_context.cpp | 2 +- sycl/unittests/pi/cuda/test_queue.cpp | 2 +- 13 files changed, 119 insertions(+), 160 deletions(-) diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp index 95b5a654daaaa..4ad87ca01cb73 100644 --- a/sycl/unittests/pi/EnqueueMemTest.cpp +++ b/sycl/unittests/pi/EnqueueMemTest.cpp @@ -61,12 +61,11 @@ class EnqueueMemTest : public testing::TestWithParam { ASSERT_EQ((plugin.call_nocheck(_mem)), PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(_queue)), + PI_SUCCESS); ASSERT_EQ( - (plugin.call_nocheck(_queue)), + (plugin.call_nocheck(_context)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( - _context)), - PI_SUCCESS); } template void TestBufferFill(const T &pattern) { @@ -79,24 +78,21 @@ class EnqueueMemTest : public testing::TestWithParam { ASSERT_NE(pattern, inValues[i]); } - ASSERT_EQ( - (plugin.call_nocheck( - _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0, - nullptr, nullptr)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, + 0, nullptr, nullptr)), + PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck( - _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr, - nullptr)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, + nullptr, nullptr)), + PI_SUCCESS); T outValues[_numElementsX] = {}; - ASSERT_EQ( - (plugin.call_nocheck( - _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0, - nullptr, nullptr)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), + outValues, 0, nullptr, nullptr)), + PI_SUCCESS); for (size_t i = 0; i < _numElementsX; ++i) { ASSERT_EQ(pattern, outValues[i]); @@ -106,52 +102,43 @@ class EnqueueMemTest : public testing::TestWithParam { static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(EnqueueMemTestImpl, - EnqueueMemTest, - testing::ValuesIn(Plugins),); +INSTANTIATE_TEST_CASE_P(EnqueueMemTestImpl, EnqueueMemTest, + testing::ValuesIn(Plugins), ); -template -struct vec4 { +template struct vec4 { T x, y, z, w; bool operator==(const vec4 &rhs) const { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } - bool operator!=(const vec4 &rhs) const { - return !(*this == rhs); - } + bool operator!=(const vec4 &rhs) const { return !(*this == rhs); } }; -template -struct vec2 { +template struct vec2 { T x, y; - bool operator==(const vec2 &rhs) const { - return x == rhs.x && y == rhs.y; - } + bool operator==(const vec2 &rhs) const { return x == rhs.x && y == rhs.y; } - bool operator!=(const vec2 &rhs) const { - return !(*this == rhs); - } + bool operator!=(const vec2 &rhs) const { return !(*this == rhs); } }; TEST_P(EnqueueMemTest, piEnqueueMemBufferFill) { - TestBufferFill(float{1}); - TestBufferFill(vec2{1, 2}); - TestBufferFill(vec4{1, 2, 3, 4}); + TestBufferFill(float{1}); + TestBufferFill(vec2{1, 2}); + TestBufferFill(vec4{1, 2, 3, 4}); - TestBufferFill(uint8_t{1}); - TestBufferFill(vec2{1, 2}); - TestBufferFill(vec4{1, 2, 3, 4}); + TestBufferFill(uint8_t{1}); + TestBufferFill(vec2{1, 2}); + TestBufferFill(vec4{1, 2, 3, 4}); - TestBufferFill(uint16_t{1}); - TestBufferFill(vec2{1, 2}); - TestBufferFill(vec4{1, 2, 3, 4}); + TestBufferFill(uint16_t{1}); + TestBufferFill(vec2{1, 2}); + TestBufferFill(vec4{1, 2, 3, 4}); - TestBufferFill(uint32_t{1}); - TestBufferFill(vec2{1, 2}); - TestBufferFill(vec4{1, 2, 3, 4}); + TestBufferFill(uint32_t{1}); + TestBufferFill(vec2{1, 2}); + TestBufferFill(vec4{1, 2, 3, 4}); } } // namespace diff --git a/sycl/unittests/pi/EventTest.cpp b/sycl/unittests/pi/EventTest.cpp index c824ac24a96a3..755ef82b6b22e 100644 --- a/sycl/unittests/pi/EventTest.cpp +++ b/sycl/unittests/pi/EventTest.cpp @@ -7,8 +7,8 @@ //===----------------------------------------------------------------------===// #include "CL/sycl/detail/pi.hpp" -#include #include +#include #include #include @@ -25,8 +25,7 @@ class EventTest : public testing::TestWithParam { EventTest() : _context{nullptr}, _queue{nullptr}, _device{nullptr}, - _result{PI_INVALID_VALUE} { - } + _result{PI_INVALID_VALUE} {} ~EventTest() override = default; @@ -65,21 +64,18 @@ class EventTest : public testing::TestWithParam { detail::plugin plugin = GetParam(); + ASSERT_EQ((plugin.call_nocheck(_queue)), + PI_SUCCESS); + ASSERT_EQ( - (plugin.call_nocheck(_queue)), + (plugin.call_nocheck(_context)), PI_SUCCESS); - - ASSERT_EQ((plugin.call_nocheck( - _context)), - PI_SUCCESS); } }; static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(EventTestImpl, - EventTest, - testing::ValuesIn(Plugins),); +INSTANTIATE_TEST_CASE_P(EventTestImpl, EventTest, testing::ValuesIn(Plugins), ); // TODO: need more negative tests to show errors being reported when expected // (invalid arguments etc). @@ -89,9 +85,9 @@ TEST_P(EventTest, PICreateEvent) { detail::plugin plugin = GetParam(); - ASSERT_EQ((plugin.call_nocheck(_context, - &foo)), - PI_SUCCESS); + ASSERT_EQ( + (plugin.call_nocheck(_context, &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); EXPECT_EQ((plugin.call_nocheck(foo)), @@ -131,8 +127,8 @@ TEST_P(EventTest, piEventSetCallback) { // gate event lets us register callbacks before letting the enqueued work be // executed. pi_event gateEvent; - ASSERT_EQ((plugin.call_nocheck( - _context, &gateEvent)), + ASSERT_EQ((plugin.call_nocheck(_context, + &gateEvent)), PI_SUCCESS); constexpr const size_t dataCount = 1000u; @@ -146,11 +142,10 @@ TEST_P(EventTest, piEventSetCallback) { PI_SUCCESS); pi_event syncEvent; - ASSERT_EQ( - (plugin.call_nocheck( - _queue, memObj, false, 0, size_in_bytes, data.data(), 1, &gateEvent, - &syncEvent)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + _queue, memObj, false, 0, size_in_bytes, data.data(), 1, + &gateEvent, &syncEvent)), + PI_SUCCESS); for (size_t i = 0; i < event_type_count; i++) { user_data[i].event_type = event_callback_types[i]; @@ -174,12 +169,10 @@ TEST_P(EventTest, piEventSetCallback) { EXPECT_TRUE(triggered_flag[k]); } - ASSERT_EQ( - (plugin.call_nocheck(gateEvent)), - PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck(syncEvent)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(gateEvent)), + PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(syncEvent)), + PI_SUCCESS); } TEST_P(EventTest, piEventGetInfo) { @@ -187,9 +180,9 @@ TEST_P(EventTest, piEventGetInfo) { detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((plugin.call_nocheck(_context, - &foo)), - PI_SUCCESS); + ASSERT_EQ( + (plugin.call_nocheck(_context, &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_uint64 paramValue = 0; @@ -211,9 +204,9 @@ TEST_P(EventTest, piEventSetStatus) { detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((plugin.call_nocheck(_context, - &foo)), - PI_SUCCESS); + ASSERT_EQ( + (plugin.call_nocheck(_context, &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = PI_EVENT_QUEUED; @@ -243,9 +236,9 @@ TEST_P(EventTest, WaitForManualEventOnOtherThread) { detail::plugin plugin = GetParam(); pi_event foo; - ASSERT_EQ((plugin.call_nocheck(_context, - &foo)), - PI_SUCCESS); + ASSERT_EQ( + (plugin.call_nocheck(_context, &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = {}; @@ -260,9 +253,8 @@ TEST_P(EventTest, WaitForManualEventOnOtherThread) { auto tWaiter = std::thread([&]() { started = true; - ASSERT_EQ( - (plugin.call_nocheck(1, &foo)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(1, &foo)), + PI_SUCCESS); }); while (!started) { @@ -302,10 +294,9 @@ TEST_P(EventTest, piEnqueueEventsWait) { pi_event events[4] = {nullptr, nullptr, nullptr, nullptr}; - ASSERT_EQ( - (plugin.call_nocheck( - _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])), + PI_SUCCESS); ASSERT_NE(events[0], nullptr); ASSERT_EQ( @@ -314,8 +305,8 @@ TEST_P(EventTest, piEnqueueEventsWait) { PI_SUCCESS); ASSERT_NE(events[1], nullptr); - ASSERT_EQ((plugin.call_nocheck( - _context, &events[2])), + ASSERT_EQ((plugin.call_nocheck(_context, + &events[2])), PI_SUCCESS); ASSERT_NE(events[2], nullptr); diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp index fdc5cdb68f1c3..2068bffff63f3 100644 --- a/sycl/unittests/pi/PlatformTest.cpp +++ b/sycl/unittests/pi/PlatformTest.cpp @@ -46,8 +46,7 @@ class PlatformTest : public testing::TestWithParam { RecordProperty(platform_count_key, platform_count); if (platform_count == 0u) { - std::cout - << "WARNING: piPlatformsGet does not find any PI platforms.\n"; + std::cout << "WARNING: piPlatformsGet does not find any PI platforms.\n"; // Do not call into OpenCL below as a platform count of 0 might fail with // OpenCL implementations if the platforms pointer is not `nullptr`. @@ -64,9 +63,8 @@ class PlatformTest : public testing::TestWithParam { static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(PlatformTestImpl, - PlatformTest, - testing::ValuesIn(Plugins),); +INSTANTIATE_TEST_CASE_P(PlatformTestImpl, PlatformTest, + testing::ValuesIn(Plugins), ); TEST_P(PlatformTest, piPlatformsGet) { // The PlatformTest::SetUp method is called to prepare for this test case diff --git a/sycl/unittests/pi/cuda/test_base_objects.cpp b/sycl/unittests/pi/cuda/test_base_objects.cpp index 4ca4569351dd8..307c1d7ba1897 100644 --- a/sycl/unittests/pi/cuda/test_base_objects.cpp +++ b/sycl/unittests/pi/cuda/test_base_objects.cpp @@ -10,13 +10,13 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include #include #include -#include "test_get_plugin.hpp" const unsigned int LATEST_KNOWN_CUDA_DRIVER_API_VERSION = 3020u; @@ -115,9 +115,8 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) { cuErr = cuCtxGetCurrent(¤t); ASSERT_EQ(cuErr, CUDA_SUCCESS); ASSERT_EQ(current, cudaContext); - ASSERT_EQ( - (plugin.call_nocheck(ctxt)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(ctxt)), + PI_SUCCESS); } TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) { @@ -161,9 +160,8 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) { cuErr = cuCtxGetCurrent(¤t); ASSERT_EQ(cuErr, CUDA_SUCCESS); ASSERT_EQ(current, cudaContext); - ASSERT_EQ( - (plugin.call_nocheck(ctxt)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(ctxt)), + PI_SUCCESS); } TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) { @@ -217,7 +215,6 @@ TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) { callContextFromOtherThread.join(); - ASSERT_EQ( - (plugin.call_nocheck(ctxt)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(ctxt)), + PI_SUCCESS); } diff --git a/sycl/unittests/pi/cuda/test_commands.cpp b/sycl/unittests/pi/cuda/test_commands.cpp index cea812a434c02..5b0a424d02370 100644 --- a/sycl/unittests/pi/cuda/test_commands.cpp +++ b/sycl/unittests/pi/cuda/test_commands.cpp @@ -10,11 +10,11 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; @@ -80,10 +80,9 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) { context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck( - queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)), + PI_SUCCESS); ASSERT_EQ((plugin.call_nocheck( queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)), @@ -111,10 +110,9 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { PI_SUCCESS); pi_event cpIn, cpOut; - ASSERT_EQ( - (plugin.call_nocheck( - queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)), + PI_SUCCESS); ASSERT_NE(cpIn, nullptr); ASSERT_EQ((plugin.call_nocheck( @@ -122,9 +120,8 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { PI_SUCCESS); ASSERT_NE(cpOut, nullptr); - ASSERT_EQ( - (plugin.call_nocheck(1, &cpOut)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck(1, &cpOut)), + PI_SUCCESS); bool isSame = std::equal(std::begin(output), std::end(output), std::begin(data)); diff --git a/sycl/unittests/pi/cuda/test_device.cpp b/sycl/unittests/pi/cuda/test_device.cpp index 5f3d3a61146db..6b56ac8c2179b 100644 --- a/sycl/unittests/pi/cuda/test_device.cpp +++ b/sycl/unittests/pi/cuda/test_device.cpp @@ -10,11 +10,11 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; diff --git a/sycl/unittests/pi/cuda/test_events.cpp b/sycl/unittests/pi/cuda/test_events.cpp index 1d87b338fc52d..81c8664d8152b 100644 --- a/sycl/unittests/pi/cuda/test_events.cpp +++ b/sycl/unittests/pi/cuda/test_events.cpp @@ -10,12 +10,12 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; @@ -29,9 +29,7 @@ class CudaEventTests : public ::testing::Test { pi_queue _queue; pi_device _device; - CudaEventTests() - : _context{nullptr}, _queue{nullptr}, _device{nullptr} { - } + CudaEventTests() : _context{nullptr}, _queue{nullptr}, _device{nullptr} {} ~CudaEventTests() override = default; @@ -71,9 +69,9 @@ class CudaEventTests : public ::testing::Test { TEST_F(CudaEventTests, PICreateEvent) { pi_event foo; - ASSERT_EQ((plugin.call_nocheck(_context, - &foo)), - PI_SUCCESS); + ASSERT_EQ( + (plugin.call_nocheck(_context, &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); // There is no CUDA interop event for user events EXPECT_EQ(foo->get(), nullptr); diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp index e73acd95f2184..9af5b976dbd37 100644 --- a/sycl/unittests/pi/cuda/test_get_plugin.hpp +++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp @@ -2,19 +2,20 @@ #include #include -#include #include +#include using namespace cl::sycl; namespace pi { inline detail::plugin initializeAndGetCuda() { auto plugins = detail::pi::initialize(); - auto it = std::find_if(plugins.begin(), plugins.end(), - [](detail::plugin p) -> bool { return p.getBackend() == backend::cuda; }); - if(it == plugins.end()) { - throw std::runtime_error("PI CUDA plugin not found."); + auto it = std::find_if( + plugins.begin(), plugins.end(), + [](detail::plugin p) -> bool { return p.getBackend() == backend::cuda; }); + if (it == plugins.end()) { + throw std::runtime_error("PI CUDA plugin not found."); } return *it; } -} \ No newline at end of file +} // namespace pi \ No newline at end of file diff --git a/sycl/unittests/pi/cuda/test_interop_get_native.cpp b/sycl/unittests/pi/cuda/test_interop_get_native.cpp index a2a7e040e614a..81b6a27cbcc93 100644 --- a/sycl/unittests/pi/cuda/test_interop_get_native.cpp +++ b/sycl/unittests/pi/cuda/test_interop_get_native.cpp @@ -23,17 +23,15 @@ struct CudaInteropGetNativeTests : public ::testing::Test { device syclDevice_; CudaInteropGetNativeTests() - : syclQueue_(cuda_device_selector()) - , syclContext_(syclQueue_.get_context()) - , syclDevice_(syclQueue_.get_device()) - {} + : syclQueue_(cuda_device_selector()), + syclContext_(syclQueue_.get_context()), + syclDevice_(syclQueue_.get_device()) {} static bool isCudaDevice(const device &dev) { const platform platform = dev.get_info(); const std::string platformVersion = platform.get_info(); - const std::string platformName = - platform.get_info(); + const std::string platformName = platform.get_info(); // If using PI_CUDA, don't accept a non-CUDA device return platformVersion.find("CUDA") != std::string::npos && platformName.find("NVIDIA CUDA") != std::string::npos; diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp index 53218261cf1e9..afd95544e7ef9 100644 --- a/sycl/unittests/pi/cuda/test_kernels.cpp +++ b/sycl/unittests/pi/cuda/test_kernels.cpp @@ -10,11 +10,11 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; @@ -125,8 +125,6 @@ const char *threeParamsTwoLocal = "\n\ }\n\ "; - - TEST_F(CudaKernelsTest, PICreateProgramAndKernel) { pi_program prog; @@ -264,10 +262,9 @@ TEST_F(CudaKernelsTest, PIkerneldispatch) { context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck( - kern, 0, &memObj)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + kern, 0, &memObj)), + PI_SUCCESS); size_t workDim = 1; size_t globalWorkOffset[] = {0}; @@ -310,15 +307,13 @@ TEST_F(CudaKernelsTest, PIkerneldispatchTwo) { context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2)), PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck( - kern, 0, &memObj)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + kern, 0, &memObj)), + PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck( - kern, 1, &memObj2)), - PI_SUCCESS); + ASSERT_EQ((plugin.call_nocheck( + kern, 1, &memObj2)), + PI_SUCCESS); size_t workDim = 1; size_t globalWorkOffset[] = {0}; @@ -335,8 +330,6 @@ TEST_F(CudaKernelsTest, PIkerneldispatchTwo) { PI_SUCCESS); } - - TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { pi_program prog; @@ -378,5 +371,4 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { ASSERT_EQ(kernArgs3.size(), (size_t)3); storedValue = *(static_cast(kernArgs3[2])); ASSERT_EQ(storedValue, static_cast(sizeof(int))); - } diff --git a/sycl/unittests/pi/cuda/test_mem_obj.cpp b/sycl/unittests/pi/cuda/test_mem_obj.cpp index 8996ecec501d5..dac5f28562d39 100644 --- a/sycl/unittests/pi/cuda/test_mem_obj.cpp +++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp @@ -10,12 +10,12 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; diff --git a/sycl/unittests/pi/cuda/test_primary_context.cpp b/sycl/unittests/pi/cuda/test_primary_context.cpp index a34d3491b6358..f23c0dddacb5e 100644 --- a/sycl/unittests/pi/cuda/test_primary_context.cpp +++ b/sycl/unittests/pi/cuda/test_primary_context.cpp @@ -10,11 +10,11 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include -#include "test_get_plugin.hpp" #include diff --git a/sycl/unittests/pi/cuda/test_queue.cpp b/sycl/unittests/pi/cuda/test_queue.cpp index da5ae818d484f..ce47ddb2d1d20 100644 --- a/sycl/unittests/pi/cuda/test_queue.cpp +++ b/sycl/unittests/pi/cuda/test_queue.cpp @@ -10,12 +10,12 @@ #include +#include "test_get_plugin.hpp" #include #include #include #include #include -#include "test_get_plugin.hpp" using namespace cl::sycl; From c448c80c6b00e50f6aaae6deb030d91cea26a7b6 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Fri, 8 May 2020 14:20:06 +0100 Subject: [PATCH 3/7] Print PI API backend name when running tests Signed-off-by: Stuart Adams --- sycl/unittests/pi/BackendString.hpp | 21 +++++++++++++++++++++ sycl/unittests/pi/EnqueueMemTest.cpp | 8 ++++++-- sycl/unittests/pi/EventTest.cpp | 15 ++++++++++----- sycl/unittests/pi/PiMock.cpp | 1 - sycl/unittests/pi/PlatformTest.cpp | 8 ++++++-- 5 files changed, 43 insertions(+), 10 deletions(-) create mode 100644 sycl/unittests/pi/BackendString.hpp diff --git a/sycl/unittests/pi/BackendString.hpp b/sycl/unittests/pi/BackendString.hpp new file mode 100644 index 0000000000000..eecd26ff4253c --- /dev/null +++ b/sycl/unittests/pi/BackendString.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include + +using namespace cl::sycl; + +namespace pi { +inline const char *GetBackendString(backend backend) { + switch (backend) { +#define PI_BACKEND_STR(backend_name) \ + case cl::sycl::backend::backend_name: \ + return #backend_name + PI_BACKEND_STR(cuda); + PI_BACKEND_STR(host); + PI_BACKEND_STR(opencl); +#undef PI_BACKEND_STR + default: + return "Unknown Plugin"; + } +} +} // namespace pi \ No newline at end of file diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp index 4ad87ca01cb73..53bc06b365e21 100644 --- a/sycl/unittests/pi/EnqueueMemTest.cpp +++ b/sycl/unittests/pi/EnqueueMemTest.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "BackendString.hpp" #include #include #include @@ -102,8 +103,11 @@ class EnqueueMemTest : public testing::TestWithParam { static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(EnqueueMemTestImpl, EnqueueMemTest, - testing::ValuesIn(Plugins), ); +INSTANTIATE_TEST_CASE_P( + EnqueueMemTestImpl, EnqueueMemTest, testing::ValuesIn(Plugins), + [](const testing::TestParamInfo &info) { + return pi::GetBackendString(info.param.getBackend()); + }); template struct vec4 { T x, y, z, w; diff --git a/sycl/unittests/pi/EventTest.cpp b/sycl/unittests/pi/EventTest.cpp index 755ef82b6b22e..7260c39b5707b 100644 --- a/sycl/unittests/pi/EventTest.cpp +++ b/sycl/unittests/pi/EventTest.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "BackendString.hpp" #include "CL/sycl/detail/pi.hpp" #include #include @@ -34,15 +35,15 @@ class EventTest : public testing::TestWithParam { detail::plugin plugin = GetParam(); + RecordProperty("PiBackend", GetBackendString(plugin.getBackend())); + ASSERT_EQ((plugin.call_nocheck( 0, nullptr, &numPlatforms)), - PI_SUCCESS) - << "piPlatformsGet failed.\n"; + PI_SUCCESS); ASSERT_EQ((plugin.call_nocheck( numPlatforms, &_platform, nullptr)), - PI_SUCCESS) - << "piPlatformsGet failed.\n"; + PI_SUCCESS); (void)numPlatforms; // Deal with unused variable warning ASSERT_EQ((plugin.call_nocheck( @@ -75,7 +76,11 @@ class EventTest : public testing::TestWithParam { static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(EventTestImpl, EventTest, testing::ValuesIn(Plugins), ); +INSTANTIATE_TEST_CASE_P( + EventTestImpl, EventTest, testing::ValuesIn(Plugins), + [](const testing::TestParamInfo &info) { + return pi::GetBackendString(info.param.getBackend()); + }); // TODO: need more negative tests to show errors being reported when expected // (invalid arguments etc). diff --git a/sycl/unittests/pi/PiMock.cpp b/sycl/unittests/pi/PiMock.cpp index 0f415a3b23aa4..88d727a0f0968 100644 --- a/sycl/unittests/pi/PiMock.cpp +++ b/sycl/unittests/pi/PiMock.cpp @@ -8,7 +8,6 @@ #include #include - #include using namespace cl::sycl; diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp index 2068bffff63f3..ec9e4431aaa65 100644 --- a/sycl/unittests/pi/PlatformTest.cpp +++ b/sycl/unittests/pi/PlatformTest.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "BackendString.hpp" #include #include #include @@ -63,8 +64,11 @@ class PlatformTest : public testing::TestWithParam { static std::vector Plugins = detail::pi::initialize(); -INSTANTIATE_TEST_CASE_P(PlatformTestImpl, PlatformTest, - testing::ValuesIn(Plugins), ); +INSTANTIATE_TEST_CASE_P( + PlatformTestImpl, PlatformTest, testing::ValuesIn(Plugins), + [](const testing::TestParamInfo &info) { + return pi::GetBackendString(info.param.getBackend()); + }); TEST_P(PlatformTest, piPlatformsGet) { // The PlatformTest::SetUp method is called to prepare for this test case From 39a85a89a3b2528c4cbc5ddd5a4aab4d17390493 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Mon, 11 May 2020 16:54:51 +0100 Subject: [PATCH 4/7] Documented pi_device_type Signed-off-by: Stuart Adams --- sycl/include/CL/sycl/detail/pi.h | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/sycl/include/CL/sycl/detail/pi.h b/sycl/include/CL/sycl/detail/pi.h index 8848439dc0f22..7da7d788e01ae 100644 --- a/sycl/include/CL/sycl/detail/pi.h +++ b/sycl/include/CL/sycl/detail/pi.h @@ -132,11 +132,16 @@ typedef enum { // make the translation to OpenCL transparent. // typedef enum : pi_uint64 { - PI_DEVICE_TYPE_DEFAULT = CL_DEVICE_TYPE_DEFAULT, - PI_DEVICE_TYPE_ALL = CL_DEVICE_TYPE_ALL, - PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU, - PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, - PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR + PI_DEVICE_TYPE_DEFAULT = + CL_DEVICE_TYPE_DEFAULT, ///< The default device available in the PI + ///< plugin. + PI_DEVICE_TYPE_ALL = + CL_DEVICE_TYPE_ALL, ///< All devices available in the PI plugin. + PI_DEVICE_TYPE_CPU = + CL_DEVICE_TYPE_CPU, ///< A PI device that is the host processor. + PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, ///< A PI device that is a GPU. + PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR ///< A PI device that is a + ///< dedicated accelerator. } _pi_device_type; typedef enum { From a07f0f70d5f0b56a4fa5330513e14fd968a8f482 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Tue, 12 May 2020 13:30:09 +0100 Subject: [PATCH 5/7] Implemented PR feedback, cleaned up new header files. --- sycl/unittests/pi/BackendString.hpp | 8 +++++--- sycl/unittests/pi/cuda/test_get_plugin.hpp | 7 ++++--- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/sycl/unittests/pi/BackendString.hpp b/sycl/unittests/pi/BackendString.hpp index eecd26ff4253c..ee3d212fc70ee 100644 --- a/sycl/unittests/pi/BackendString.hpp +++ b/sycl/unittests/pi/BackendString.hpp @@ -1,11 +1,13 @@ +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + #pragma once #include -using namespace cl::sycl; - namespace pi { -inline const char *GetBackendString(backend backend) { +inline const char *GetBackendString(cl::sycl::backend backend) { switch (backend) { #define PI_BACKEND_STR(backend_name) \ case cl::sycl::backend::backend_name: \ diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp index 9af5b976dbd37..4b020df7321e4 100644 --- a/sycl/unittests/pi/cuda/test_get_plugin.hpp +++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp @@ -1,8 +1,9 @@ +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + #pragma once -#include -#include -#include #include using namespace cl::sycl; From 0f9e31030a5ea9b97b85d7c4c04c81e94780ea56 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Tue, 12 May 2020 14:11:32 +0100 Subject: [PATCH 6/7] Removed using namespace from unit test header. --- sycl/unittests/pi/cuda/test_get_plugin.hpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp index 4b020df7321e4..fd5adb0047795 100644 --- a/sycl/unittests/pi/cuda/test_get_plugin.hpp +++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp @@ -6,14 +6,12 @@ #include -using namespace cl::sycl; - namespace pi { -inline detail::plugin initializeAndGetCuda() { - auto plugins = detail::pi::initialize(); +inline cl::sycl::detail::plugin initializeAndGetCuda() { + auto plugins = cl::sycl::detail::pi::initialize(); auto it = std::find_if( plugins.begin(), plugins.end(), - [](detail::plugin p) -> bool { return p.getBackend() == backend::cuda; }); + [](cl::sycl::detail::plugin p) -> bool { return p.getBackend() == cl::sycl::backend::cuda; }); if (it == plugins.end()) { throw std::runtime_error("PI CUDA plugin not found."); } From 8cc36a6883764065063ee5da7338bfde01f27bb0 Mon Sep 17 00:00:00 2001 From: Stuart Adams Date: Tue, 12 May 2020 14:12:14 +0100 Subject: [PATCH 7/7] Clang format Signed-off-by: Stuart Adams --- sycl/unittests/pi/cuda/test_get_plugin.hpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp index fd5adb0047795..f050fa6f467a2 100644 --- a/sycl/unittests/pi/cuda/test_get_plugin.hpp +++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp @@ -9,9 +9,10 @@ namespace pi { inline cl::sycl::detail::plugin initializeAndGetCuda() { auto plugins = cl::sycl::detail::pi::initialize(); - auto it = std::find_if( - plugins.begin(), plugins.end(), - [](cl::sycl::detail::plugin p) -> bool { return p.getBackend() == cl::sycl::backend::cuda; }); + auto it = std::find_if(plugins.begin(), plugins.end(), + [](cl::sycl::detail::plugin p) -> bool { + return p.getBackend() == cl::sycl::backend::cuda; + }); if (it == plugins.end()) { throw std::runtime_error("PI CUDA plugin not found."); }