From 43f2972584bcfa4b8c87b50040791392120e3de3 Mon Sep 17 00:00:00 2001 From: Vladimir Lazarev Date: Fri, 15 May 2020 13:55:24 +0300 Subject: [PATCH] Revert "[SYCL] Enable PI unit testing on multiple plugins. (#1647)" This reverts commit 98119bd1fd25c301deb7007b346b2f95a249a5d8. --- sycl/include/CL/sycl/detail/pi.h | 13 +- sycl/plugins/cuda/pi_cuda.cpp | 9 +- sycl/unittests/pi/BackendString.hpp | 23 --- sycl/unittests/pi/CMakeLists.txt | 2 +- sycl/unittests/pi/EnqueueMemTest.cpp | 118 +++++------ sycl/unittests/pi/EventTest.cpp | 191 ++++++++---------- sycl/unittests/pi/PiMock.cpp | 1 + sycl/unittests/pi/PlatformTest.cpp | 35 +--- sycl/unittests/pi/cuda/test_base_objects.cpp | 66 +++--- sycl/unittests/pi/cuda/test_commands.cpp | 56 ++--- sycl/unittests/pi/cuda/test_device.cpp | 34 ++-- sycl/unittests/pi/cuda/test_events.cpp | 44 ++-- sycl/unittests/pi/cuda/test_get_plugin.hpp | 21 -- .../pi/cuda/test_interop_get_native.cpp | 30 ++- sycl/unittests/pi/cuda/test_kernels.cpp | 142 +++++++------ sycl/unittests/pi/cuda/test_mem_obj.cpp | 35 ++-- .../pi/cuda/test_primary_context.cpp | 9 +- sycl/unittests/pi/cuda/test_queue.cpp | 55 +++-- 18 files changed, 406 insertions(+), 478 deletions(-) delete mode 100644 sycl/unittests/pi/BackendString.hpp delete 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 551b3f449135b..854c7387817cf 100644 --- a/sycl/include/CL/sycl/detail/pi.h +++ b/sycl/include/CL/sycl/detail/pi.h @@ -133,16 +133,9 @@ typedef enum { // make the translation to OpenCL transparent. // typedef enum : pi_uint64 { - 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_CPU = CL_DEVICE_TYPE_CPU, + PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, + PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR } _pi_device_type; typedef enum { diff --git a/sycl/plugins/cuda/pi_cuda.cpp b/sycl/plugins/cuda/pi_cuda.cpp index f05b3ba874bc0..8a4d9540334a4 100644 --- a/sycl/plugins/cuda/pi_cuda.cpp +++ b/sycl/plugins/cuda/pi_cuda.cpp @@ -716,18 +716,15 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type, pi_uint32 *num_devices) { pi_result err = PI_SUCCESS; - 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; + const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU); + size_t numDevices = askingForGPU ? platform->devices_.size() : 0; try { if (num_devices) { *num_devices = numDevices; } - if (returnDevices && devices) { + if (askingForGPU && 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/BackendString.hpp b/sycl/unittests/pi/BackendString.hpp deleted file mode 100644 index ee3d212fc70ee..0000000000000 --- a/sycl/unittests/pi/BackendString.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// 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 - -namespace pi { -inline const char *GetBackendString(cl::sycl::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/CMakeLists.txt b/sycl/unittests/pi/CMakeLists.txt index fbaf61fea440f..814f7da464508 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 53bc06b365e21..d8cbcee51eaeb 100644 --- a/sycl/unittests/pi/EnqueueMemTest.cpp +++ b/sycl/unittests/pi/EnqueueMemTest.cpp @@ -6,7 +6,6 @@ // //===----------------------------------------------------------------------===// -#include "BackendString.hpp" #include #include #include @@ -14,8 +13,10 @@ using namespace cl::sycl; namespace { -class EnqueueMemTest : public testing::TestWithParam { +class DISABLED_EnqueueMemTest : public ::testing::Test { protected: + std::vector Plugins; + constexpr static size_t _numElementsX = 8; constexpr static size_t _numElementsY = 4; @@ -24,76 +25,75 @@ class EnqueueMemTest : public testing::TestWithParam { pi_queue _queue = nullptr; pi_mem _mem = nullptr; - EnqueueMemTest() = default; + DISABLED_EnqueueMemTest() = default; - ~EnqueueMemTest() = default; + ~DISABLED_EnqueueMemTest() = default; void SetUp() override { - - detail::plugin plugin = GetParam(); + Plugins = detail::pi::initialize(); + ASSERT_FALSE(Plugins.empty()); pi_platform platform = nullptr; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 1, &platform, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( - platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)), + ASSERT_EQ((Plugins[0].call_nocheck( + platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); pi_result result = PI_INVALID_VALUE; - result = plugin.call_nocheck( + result = Plugins[0].call_nocheck( nullptr, 1u, &_device, nullptr, nullptr, &_context); ASSERT_EQ(result, PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32), nullptr, &_mem)), PI_SUCCESS); } void TearDown() override { - - detail::plugin plugin = GetParam(); - - ASSERT_EQ((plugin.call_nocheck(_mem)), - PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(_queue)), + ASSERT_EQ((Plugins[0].call_nocheck(_mem)), PI_SUCCESS); ASSERT_EQ( - (plugin.call_nocheck(_context)), + (Plugins[0].call_nocheck(_queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].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) { 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( + (Plugins[0].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( + (Plugins[0].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( + (Plugins[0].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]); @@ -101,48 +101,48 @@ class EnqueueMemTest : public testing::TestWithParam { } }; -static std::vector Plugins = detail::pi::initialize(); - -INSTANTIATE_TEST_CASE_P( - EnqueueMemTestImpl, EnqueueMemTest, testing::ValuesIn(Plugins), - [](const testing::TestParamInfo &info) { - return pi::GetBackendString(info.param.getBackend()); - }); - -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) { +TEST_F(DISABLED_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 7260c39b5707b..d3c88b9db97a7 100644 --- a/sycl/unittests/pi/EventTest.cpp +++ b/sycl/unittests/pi/EventTest.cpp @@ -6,55 +6,57 @@ // //===----------------------------------------------------------------------===// -#include "BackendString.hpp" #include "CL/sycl/detail/pi.hpp" -#include #include +#include #include #include using namespace cl::sycl; namespace pi { -class EventTest : public testing::TestWithParam { +class DISABLED_EventTest : public ::testing::Test { protected: + std::vector Plugins; + pi_platform _platform; pi_context _context; pi_queue _queue; pi_device _device; pi_result _result; - EventTest() + DISABLED_EventTest() : _context{nullptr}, _queue{nullptr}, _device{nullptr}, - _result{PI_INVALID_VALUE} {} + _result{PI_INVALID_VALUE} { + Plugins = detail::pi::initialize(); + } - ~EventTest() override = default; + ~DISABLED_EventTest() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - detail::plugin plugin = GetParam(); - - RecordProperty("PiBackend", GetBackendString(plugin.getBackend())); - - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), - PI_SUCCESS); + PI_SUCCESS) + << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &_platform, nullptr)), - PI_SUCCESS); + PI_SUCCESS) + << "piPlatformsGet failed.\n"; (void)numPlatforms; // Deal with unused variable warning - ASSERT_EQ((plugin.call_nocheck( - _platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)), + ASSERT_EQ((Plugins[0].call_nocheck( + _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); @@ -63,39 +65,27 @@ class EventTest : public testing::TestWithParam { void TearDown() override { - detail::plugin plugin = GetParam(); - - ASSERT_EQ((plugin.call_nocheck(_queue)), - PI_SUCCESS); - ASSERT_EQ( - (plugin.call_nocheck(_context)), + (Plugins[0].call_nocheck(_queue)), PI_SUCCESS); + + ASSERT_EQ((Plugins[0].call_nocheck( + _context)), + PI_SUCCESS); } }; -static std::vector Plugins = detail::pi::initialize(); - -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). -TEST_P(EventTest, PICreateEvent) { +TEST_F(DISABLED_EventTest, PICreateEvent) { pi_event foo; - - detail::plugin plugin = GetParam(); - - ASSERT_EQ( - (plugin.call_nocheck(_context, &foo)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_context, + &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); - EXPECT_EQ((plugin.call_nocheck(foo)), + EXPECT_EQ((Plugins[0].call_nocheck(foo)), PI_SUCCESS); } @@ -120,9 +110,7 @@ void EventCallback(pi_event event, pi_int32 status, void *data) { triggered_flag[pdata->index] = true; } -TEST_P(EventTest, piEventSetCallback) { - - detail::plugin plugin = GetParam(); +TEST_F(DISABLED_EventTest, piEventSetCallback) { pi_int32 event_callback_types[event_type_count] = { PI_EVENT_SUBMITTED, PI_EVENT_RUNNING, PI_EVENT_COMPLETE}; @@ -132,8 +120,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((Plugins[0].call_nocheck( + _context, &gateEvent)), PI_SUCCESS); constexpr const size_t dataCount = 1000u; @@ -142,57 +130,58 @@ TEST_P(EventTest, piEventSetCallback) { pi_mem memObj; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( _context, PI_MEM_FLAGS_ACCESS_RW, size_in_bytes, nullptr, &memObj)), 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( + (Plugins[0].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]; user_data[i].index = i; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( syncEvent, event_callback_types[i], EventCallback, user_data + i)), PI_SUCCESS); } - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( gateEvent, PI_EVENT_COMPLETE)), PI_SUCCESS); ASSERT_EQ( - (plugin.call_nocheck(1, &syncEvent)), + (Plugins[0].call_nocheck(1, &syncEvent)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(_queue)), + ASSERT_EQ((Plugins[0].call_nocheck(_queue)), PI_SUCCESS); for (size_t k = 0; k < event_type_count; ++k) { EXPECT_TRUE(triggered_flag[k]); } - ASSERT_EQ((plugin.call_nocheck(gateEvent)), - PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(syncEvent)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(gateEvent)), + PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(syncEvent)), + PI_SUCCESS); } -TEST_P(EventTest, piEventGetInfo) { - - detail::plugin plugin = GetParam(); +TEST_F(DISABLED_EventTest, piEventGetInfo) { pi_event foo; - ASSERT_EQ( - (plugin.call_nocheck(_context, &foo)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_context, + &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_uint64 paramValue = 0; pi_uint64 retSize = 0; - EXPECT_EQ((plugin.call_nocheck( + EXPECT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -200,55 +189,51 @@ TEST_P(EventTest, piEventGetInfo) { EXPECT_EQ(retSize, sizeof(pi_int32)); EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED); - EXPECT_EQ((plugin.call_nocheck(foo)), + EXPECT_EQ((Plugins[0].call_nocheck(foo)), PI_SUCCESS); } -TEST_P(EventTest, piEventSetStatus) { - - detail::plugin plugin = GetParam(); +TEST_F(DISABLED_EventTest, piEventSetStatus) { pi_event foo; - ASSERT_EQ( - (plugin.call_nocheck(_context, &foo)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_context, + &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = PI_EVENT_QUEUED; size_t retSize = 0u; - plugin.call_nocheck( + Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize); - EXPECT_EQ((plugin.call_nocheck( + EXPECT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_COMPLETE)), PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_COMPLETE); - EXPECT_EQ((plugin.call_nocheck(foo)), + EXPECT_EQ((Plugins[0].call_nocheck(foo)), PI_SUCCESS); } -TEST_P(EventTest, WaitForManualEventOnOtherThread) { - - detail::plugin plugin = GetParam(); +TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) { pi_event foo; - ASSERT_EQ( - (plugin.call_nocheck(_context, &foo)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_context, + &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -258,14 +243,15 @@ TEST_P(EventTest, WaitForManualEventOnOtherThread) { auto tWaiter = std::thread([&]() { started = true; - ASSERT_EQ((plugin.call_nocheck(1, &foo)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(1, &foo)), + PI_SUCCESS); }); while (!started) { }; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_COMPLETE)), PI_SUCCESS); @@ -273,19 +259,17 @@ TEST_P(EventTest, WaitForManualEventOnOtherThread) { paramValue = {}; retSize = 0u; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_COMPLETE); - ASSERT_EQ((plugin.call_nocheck(foo)), + ASSERT_EQ((Plugins[0].call_nocheck(foo)), PI_SUCCESS); } -TEST_P(EventTest, piEnqueueEventsWait) { - - detail::plugin plugin = GetParam(); +TEST_F(DISABLED_EventTest, piEnqueueEventsWait) { constexpr const size_t dataCount = 10u; int output[dataCount] = {}; @@ -293,52 +277,53 @@ TEST_P(EventTest, piEnqueueEventsWait) { constexpr const size_t bytes = sizeof(data); pi_mem memObj; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _context, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); 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( + (Plugins[0].call_nocheck( + _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])), + PI_SUCCESS); ASSERT_NE(events[0], nullptr); ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( _queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])), PI_SUCCESS); ASSERT_NE(events[1], nullptr); - ASSERT_EQ((plugin.call_nocheck(_context, - &events[2])), + ASSERT_EQ((Plugins[0].call_nocheck( + _context, &events[2])), PI_SUCCESS); ASSERT_NE(events[2], nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _queue, 3, events, &events[3])), PI_SUCCESS); ASSERT_NE(events[3], nullptr); pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); ASSERT_NE(paramValue, PI_EVENT_COMPLETE); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( events[2], PI_EVENT_COMPLETE)), PI_SUCCESS); ASSERT_EQ( - (plugin.call_nocheck(1, &events[3])), + (Plugins[0].call_nocheck(1, &events[3])), PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); diff --git a/sycl/unittests/pi/PiMock.cpp b/sycl/unittests/pi/PiMock.cpp index 88d727a0f0968..0f415a3b23aa4 100644 --- a/sycl/unittests/pi/PiMock.cpp +++ b/sycl/unittests/pi/PiMock.cpp @@ -8,6 +8,7 @@ #include #include + #include using namespace cl::sycl; diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp index ec9e4431aaa65..f04f6dea2de09 100644 --- a/sycl/unittests/pi/PlatformTest.cpp +++ b/sycl/unittests/pi/PlatformTest.cpp @@ -6,7 +6,6 @@ // //===----------------------------------------------------------------------===// -#include "BackendString.hpp" #include #include #include @@ -17,17 +16,15 @@ namespace { using namespace cl::sycl; -class PlatformTest : public testing::TestWithParam { +class PlatformTest : public ::testing::Test { protected: std::vector _platforms; - PlatformTest() : _platforms{} {}; + std::vector Plugins; + PlatformTest() : _platforms{} { Plugins = detail::pi::initialize(); }; ~PlatformTest() override = default; void SetUp() { - - detail::plugin plugin = GetParam(); - ASSERT_NO_FATAL_FAILURE(Test::SetUp()); const static char *platform_count_key = "PiPlatformCount"; @@ -39,7 +36,7 @@ class PlatformTest : public testing::TestWithParam { // TODO: Change the test to check this for all plugins present. // Currently, it is only checking for the first plugin attached. - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &platform_count)), PI_SUCCESS); @@ -47,7 +44,8 @@ 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`. @@ -56,39 +54,28 @@ class PlatformTest : public testing::TestWithParam { _platforms.resize(platform_count, nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _platforms.size(), _platforms.data(), nullptr)), PI_SUCCESS); } }; -static std::vector Plugins = detail::pi::initialize(); - -INSTANTIATE_TEST_CASE_P( - PlatformTestImpl, PlatformTest, testing::ValuesIn(Plugins), - [](const testing::TestParamInfo &info) { - return pi::GetBackendString(info.param.getBackend()); - }); - -TEST_P(PlatformTest, piPlatformsGet) { +TEST_F(PlatformTest, piPlatformsGet) { // The PlatformTest::SetUp method is called to prepare for this test case // implicitly tests the calls to `piPlatformsGet`. } -TEST_P(PlatformTest, piPlatformGetInfo) { - - detail::plugin plugin = GetParam(); - +TEST_F(PlatformTest, piPlatformGetInfo) { auto get_info_test = [&](pi_platform platform, _pi_platform_info info) { size_t reported_string_length = 0; - EXPECT_EQ((plugin.call_nocheck( + EXPECT_EQ((Plugins[0].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( - (plugin.call_nocheck( + (Plugins[0].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 307c1d7ba1897..34c361a5c43f1 100644 --- a/sycl/unittests/pi/cuda/test_base_objects.cpp +++ b/sycl/unittests/pi/cuda/test_base_objects.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -22,27 +21,27 @@ const unsigned int LATEST_KNOWN_CUDA_DRIVER_API_VERSION = 3020u; using namespace cl::sycl; -class CudaBaseObjectsTest : public ::testing::Test { +class DISABLED_CudaBaseObjectsTest : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; - CudaBaseObjectsTest() = default; + DISABLED_CudaBaseObjectsTest() { Plugins = detail::pi::initialize(); } - ~CudaBaseObjectsTest() = default; + ~DISABLED_CudaBaseObjectsTest() = default; }; -TEST_F(CudaBaseObjectsTest, piContextCreate) { +TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) { pi_uint32 numPlatforms = 0; pi_platform platform = nullptr; pi_device device; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; @@ -50,13 +49,13 @@ TEST_F(CudaBaseObjectsTest, piContextCreate) { ASSERT_GE(numPlatforms, 1u); ASSERT_NE(platform, nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS) << "piDevicesGet failed.\n"; pi_context ctxt = nullptr; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS) << "piContextCreate failed.\n"; @@ -74,29 +73,29 @@ TEST_F(CudaBaseObjectsTest, piContextCreate) { ASSERT_EQ(cuErr, CUDA_SUCCESS); } -TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) { +TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryTrue) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( properties, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -115,33 +114,34 @@ 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( + (Plugins[0].call_nocheck(ctxt)), + PI_SUCCESS); } -TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) { +TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryFalse) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( properties, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -160,31 +160,32 @@ 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( + (Plugins[0].call_nocheck(ctxt)), + PI_SUCCESS); } -TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) { +TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { pi_uint32 numPlatforms = 0; pi_platform platform; pi_device device; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); pi_context ctxt; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); EXPECT_NE(ctxt, nullptr); @@ -215,6 +216,7 @@ TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) { callContextFromOtherThread.join(); - ASSERT_EQ((plugin.call_nocheck(ctxt)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(ctxt)), + PI_SUCCESS); } diff --git a/sycl/unittests/pi/cuda/test_commands.cpp b/sycl/unittests/pi/cuda/test_commands.cpp index 5b0a424d02370..cce61e9fdd418 100644 --- a/sycl/unittests/pi/cuda/test_commands.cpp +++ b/sycl/unittests/pi/cuda/test_commands.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -18,10 +17,10 @@ using namespace cl::sycl; -struct CudaCommandsTest : public ::testing::Test { +struct DISABLED_CudaCommandsTest : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; pi_platform platform_; pi_device device_; @@ -31,27 +30,27 @@ struct CudaCommandsTest : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, 0, &queue_)), PI_SUCCESS); ASSERT_NE(queue_, nullptr); @@ -60,31 +59,32 @@ struct CudaCommandsTest : public ::testing::Test { } void TearDown() override { - plugin.call(queue_); - plugin.call(context_); + Plugins[0].call(queue_); + Plugins[0].call(context_); } - CudaCommandsTest() = default; + DISABLED_CudaCommandsTest() { Plugins = detail::pi::initialize(); } - ~CudaCommandsTest() = default; + ~DISABLED_CudaCommandsTest() = default; }; -TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) { +TEST_F(DISABLED_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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 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( + (Plugins[0].call_nocheck( + queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)), + PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)), PI_SUCCESS); @@ -98,30 +98,32 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) { } } -TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { +TEST_F(DISABLED_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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), PI_SUCCESS); pi_event cpIn, cpOut; - ASSERT_EQ((plugin.call_nocheck( - queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)), + PI_SUCCESS); ASSERT_NE(cpIn, nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( queue_, memObj, false, 0, bytes, output, 0, nullptr, &cpOut)), PI_SUCCESS); ASSERT_NE(cpOut, nullptr); - ASSERT_EQ((plugin.call_nocheck(1, &cpOut)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].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 6b56ac8c2179b..d4f9e2bb01939 100644 --- a/sycl/unittests/pi/cuda/test_device.cpp +++ b/sycl/unittests/pi/cuda/test_device.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -18,10 +17,10 @@ using namespace cl::sycl; -struct CudaDeviceTests : public ::testing::Test { +struct DISABLED_CudaDeviceTests : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; pi_platform platform_; pi_device device_; @@ -29,41 +28,42 @@ struct CudaDeviceTests : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - plugin.call(device_); - plugin.call(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } - CudaDeviceTests() = default; - ~CudaDeviceTests() = default; + DISABLED_CudaDeviceTests() { detail::pi::initialize(); } + + ~DISABLED_CudaDeviceTests() = default; }; -TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) { +TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { size_t return_size = 0; pi_device_type device_type; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( device_, PI_DEVICE_INFO_TYPE, sizeof(pi_device_type), &device_type, &return_size)), PI_SUCCESS); @@ -73,7 +73,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) { PI_DEVICE_TYPE_GPU); // backend pre-defined value, device must be a GPU pi_device parent_device = nullptr; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( device_, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(pi_device), &parent_device, &return_size)), PI_SUCCESS); @@ -82,7 +82,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) { nullptr); // backend pre-set value, device cannot have a parent pi_platform platform = nullptr; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( device_, PI_DEVICE_INFO_PLATFORM, sizeof(pi_platform), &platform, &return_size)), PI_SUCCESS); @@ -91,7 +91,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) { // test fixture platform cl_device_partition_property device_partition_property = -1; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].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 81c8664d8152b..e853cdd1c47c7 100644 --- a/sycl/unittests/pi/cuda/test_events.cpp +++ b/sycl/unittests/pi/cuda/test_events.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -20,73 +19,76 @@ using namespace cl::sycl; namespace pi { -class CudaEventTests : public ::testing::Test { +class DISABLED_CudaEventTests : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; pi_platform _platform; pi_context _context; pi_queue _queue; pi_device _device; - CudaEventTests() : _context{nullptr}, _queue{nullptr}, _device{nullptr} {} + DISABLED_CudaEventTests() + : _context{nullptr}, _queue{nullptr}, _device{nullptr} { + Plugins = detail::pi::initialize(); + } - ~CudaEventTests() override = default; + ~DISABLED_CudaEventTests() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &_platform, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( _context, _device, 0, &_queue)), PI_SUCCESS); } void TearDown() override { - plugin.call(_queue); - plugin.call(_context); + Plugins[0].call(_queue); + Plugins[0].call(_context); } }; -TEST_F(CudaEventTests, PICreateEvent) { +TEST_F(DISABLED_CudaEventTests, PICreateEvent) { pi_event foo; - ASSERT_EQ( - (plugin.call_nocheck(_context, &foo)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].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((plugin.call_nocheck(foo)), + ASSERT_EQ((Plugins[0].call_nocheck(foo)), PI_SUCCESS); } -TEST_F(CudaEventTests, piGetInfoNativeEvent) { +TEST_F(DISABLED_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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); @@ -99,7 +101,7 @@ TEST_F(CudaEventTests, piGetInfoNativeEvent) { auto errCode = cuEventQuery(cuEvent); ASSERT_EQ(errCode, CUDA_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(foo)), + ASSERT_EQ((Plugins[0].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 deleted file mode 100644 index f050fa6f467a2..0000000000000 --- a/sycl/unittests/pi/cuda/test_get_plugin.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// 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 - -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; - }); - if (it == plugins.end()) { - throw std::runtime_error("PI CUDA plugin not found."); - } - return *it; -} -} // 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 cfb4ab9aae2be..06cd8e92cb975 100644 --- a/sycl/unittests/pi/cuda/test_interop_get_native.cpp +++ b/sycl/unittests/pi/cuda/test_interop_get_native.cpp @@ -15,41 +15,39 @@ using namespace cl::sycl; -struct CudaInteropGetNativeTests : public ::testing::Test { +struct DISABLED_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 && - platformName.find("NVIDIA CUDA") != std::string::npos; + return platformVersion.find("CUDA") != std::string::npos; } class cuda_device_selector : public device_selector { public: int operator()(const device &dev) const { - return isCudaDevice(dev) ? 1000 : -1000; + return isCudaDevice(dev) ? 1 : -1; } }; - void SetUp() override {} + void SetUp() override { + syclQueue_ = queue{cuda_device_selector()}; + context syclContext_ = syclQueue_.get_context(); + device syclDevice_ = syclQueue_.get_device(); + ASSERT_TRUE(isCudaDevice(syclDevice_)); + } void TearDown() override {} }; -TEST_F(CudaInteropGetNativeTests, getNativeDevice) { +TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeDevice) { CUdevice cudaDevice = get_native(syclDevice_); char cudaDeviceName[2] = {0, 0}; CUresult result = cuDeviceGetName(cudaDeviceName, 2, cudaDevice); @@ -57,12 +55,12 @@ TEST_F(CudaInteropGetNativeTests, getNativeDevice) { ASSERT_NE(cudaDeviceName[0], 0); } -TEST_F(CudaInteropGetNativeTests, getNativeContext) { +TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeContext) { CUcontext cudaContext = get_native(syclContext_); ASSERT_NE(cudaContext, nullptr); } -TEST_F(CudaInteropGetNativeTests, getNativeQueue) { +TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeQueue) { CUstream cudaStream = get_native(syclQueue_); ASSERT_NE(cudaStream, nullptr); @@ -74,7 +72,7 @@ TEST_F(CudaInteropGetNativeTests, getNativeQueue) { ASSERT_EQ(streamContext, cudaContext); } -TEST_F(CudaInteropGetNativeTests, interopTaskGetMem) { +TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetMem) { buffer syclBuffer(range<1>{1}); syclQueue_.submit([&](handler &cgh) { auto syclAccessor = syclBuffer.get_access(cgh); @@ -88,7 +86,7 @@ TEST_F(CudaInteropGetNativeTests, interopTaskGetMem) { }); } -TEST_F(CudaInteropGetNativeTests, interopTaskGetBufferMem) { +TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetBufferMem) { CUstream cudaStream = get_native(syclQueue_); syclQueue_.submit([&](handler &cgh) { cgh.interop_task([=](interop_handler ih) { diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp index afd95544e7ef9..7f302f532c708 100644 --- a/sycl/unittests/pi/cuda/test_kernels.cpp +++ b/sycl/unittests/pi/cuda/test_kernels.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -18,10 +17,11 @@ using namespace cl::sycl; -struct CudaKernelsTest : public ::testing::Test { +struct DISABLED_CudaKernelsTest : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; @@ -29,27 +29,27 @@ struct CudaKernelsTest : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, 0, &queue_)), PI_SUCCESS); ASSERT_NE(queue_, nullptr); @@ -57,14 +57,14 @@ struct CudaKernelsTest : public ::testing::Test { } void TearDown() override { - plugin.call(device_); - plugin.call(queue_); - plugin.call(context_); + Plugins[0].call(device_); + Plugins[0].call(queue_); + Plugins[0].call(context_); } - CudaKernelsTest() = default; + DISABLED_CudaKernelsTest() { Plugins = detail::pi::initialize(); } - ~CudaKernelsTest() = default; + ~DISABLED_CudaKernelsTest() = default; }; const char *ptxSource = "\n\ @@ -125,44 +125,46 @@ const char *threeParamsTwoLocal = "\n\ }\n\ "; -TEST_F(CudaKernelsTest, PICreateProgramAndKernel) { + + +TEST_F(DISABLED_CudaKernelsTest, PICreateProgramAndKernel) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); ASSERT_NE(kern, nullptr); } -TEST_F(CudaKernelsTest, PIKernelArgumentSimple) { +TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -171,25 +173,25 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSimple) { ASSERT_EQ(storedValue, number); } -TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) { +TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -198,7 +200,7 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) { ASSERT_EQ(storedValue, number); int otherNumber = 934; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 0, sizeof(int), &otherNumber)), PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); @@ -207,30 +209,30 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) { ASSERT_EQ(storedValue, otherNumber); } -TEST_F(CudaKernelsTest, PIKernelSetMemObj) { +TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 0, sizeof(pi_mem), &memObj)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -239,116 +241,121 @@ TEST_F(CudaKernelsTest, PIKernelSetMemObj) { ASSERT_EQ(storedValue, memObj); } -TEST_F(CudaKernelsTest, PIkerneldispatch) { +TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatch) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( - kern, 0, &memObj)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + kern, 0, &memObj)), + PI_SUCCESS); size_t workDim = 1; size_t globalWorkOffset[] = {0}; size_t globalWorkSize[] = {1}; size_t localWorkSize[] = {1}; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( queue_, kern, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(memObj)), + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), PI_SUCCESS); } -TEST_F(CudaKernelsTest, PIkerneldispatchTwo) { +TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&twoParams, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "twoParamKernel", &kern)), PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); pi_mem memObj2; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( - kern, 0, &memObj)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + kern, 0, &memObj)), + PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( - kern, 1, &memObj2)), - PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + kern, 1, &memObj2)), + PI_SUCCESS); size_t workDim = 1; size_t globalWorkOffset[] = {0}; size_t globalWorkSize[] = {1}; size_t localWorkSize[] = {1}; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( queue_, kern, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(memObj)), + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(memObj2)), + ASSERT_EQ((Plugins[0].call_nocheck(memObj2)), PI_SUCCESS); } -TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { + + +TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { pi_program prog; ASSERT_EQ( - (plugin.call_nocheck( + (Plugins[0].call_nocheck( context_, 1, (const char **)&threeParamsTwoLocal, nullptr, &prog)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( prog, "twoParamKernelLocal", &kern)), PI_SUCCESS); int number = 10; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 0, sizeof(int), &number)), PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); @@ -356,7 +363,7 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { int storedValue = *(static_cast(kernArgs[0])); ASSERT_EQ(storedValue, number); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 1, sizeof(int), nullptr)), PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); @@ -364,11 +371,12 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { storedValue = *(static_cast(kernArgs2[1])); ASSERT_EQ(storedValue, 0); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( kern, 2, sizeof(int), nullptr)), PI_SUCCESS); const auto &kernArgs3 = kern->get_arg_indices(); 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 dac5f28562d39..8adf994ae2bdc 100644 --- a/sycl/unittests/pi/cuda/test_mem_obj.cpp +++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -19,10 +18,10 @@ using namespace cl::sycl; -struct CudaTestMemObj : public ::testing::Test { +struct DISABLED_CudaTestMemObj : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; pi_platform platform_; pi_device device_; @@ -31,49 +30,49 @@ struct CudaTestMemObj : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - plugin.call(device_); - plugin.call(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } - CudaTestMemObj() = default; + DISABLED_CudaTestMemObj() { Plugins = detail::pi::initialize(); } - ~CudaTestMemObj() = default; + ~DISABLED_CudaTestMemObj() = default; }; -TEST_F(CudaTestMemObj, piMemBufferCreateSimple) { +TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateSimple) { const size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(memObj)), + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), PI_SUCCESS); } -TEST_F(CudaTestMemObj, piMemBufferCreateNoActiveContext) { +TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateNoActiveContext) { const size_t memSize = 1024u; // Context has been destroyed @@ -93,11 +92,11 @@ TEST_F(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((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); ASSERT_NE(memObj, nullptr); - ASSERT_EQ((plugin.call_nocheck(memObj)), + ASSERT_EQ((Plugins[0].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 f23c0dddacb5e..8e387cb4a2536 100644 --- a/sycl/unittests/pi/cuda/test_primary_context.cpp +++ b/sycl/unittests/pi/cuda/test_primary_context.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -20,7 +19,7 @@ using namespace cl::sycl; -struct CudaPrimaryContextTests : public ::testing::Test { +struct DISABLED_CudaPrimaryContextTests : public ::testing::Test { protected: device deviceA_; @@ -78,7 +77,7 @@ struct CudaPrimaryContextTests : public ::testing::Test { void TearDown() override {} }; -TEST_F(CudaPrimaryContextTests, piSingleContext) { +TEST_F(DISABLED_CudaPrimaryContextTests, piSingleContext) { std::cout << "create single context" << std::endl; context Context(deviceA_, async_handler{}, /*UsePrimaryContext=*/true); @@ -93,7 +92,7 @@ TEST_F(CudaPrimaryContextTests, piSingleContext) { cuDevicePrimaryCtxRelease(CudaDevice); } -TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) { +TEST_F(DISABLED_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); @@ -104,7 +103,7 @@ TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) { ASSERT_EQ(CudaContextA, CudaContextB); } -TEST_F(CudaPrimaryContextTests, piMultiContextMultiDevice) { +TEST_F(DISABLED_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 ce47ddb2d1d20..ca983e4c55c79 100644 --- a/sycl/unittests/pi/cuda/test_queue.cpp +++ b/sycl/unittests/pi/cuda/test_queue.cpp @@ -10,7 +10,6 @@ #include -#include "test_get_plugin.hpp" #include #include #include @@ -19,10 +18,10 @@ using namespace cl::sycl; -struct CudaTestQueue : public ::testing::Test { +struct DISABLED_CudaTestQueue : public ::testing::Test { protected: - detail::plugin plugin = pi::initializeAndGetCuda(); + std::vector Plugins; pi_platform platform_; pi_device device_; @@ -30,40 +29,40 @@ struct CudaTestQueue : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; - ASSERT_EQ(plugin.getBackend(), backend::cuda); + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( numPlatforms, &platform_, nullptr)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - plugin.call(device_); - plugin.call(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } - CudaTestQueue() = default; + DISABLED_CudaTestQueue() { detail::pi::initialize(); } - ~CudaTestQueue() = default; + ~DISABLED_CudaTestQueue() = default; }; -TEST_F(CudaTestQueue, PICreateQueueSimple) { +TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) { pi_queue queue; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -74,13 +73,13 @@ TEST_F(CudaTestQueue, PICreateQueueSimple) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); } -TEST_F(CudaTestQueue, PIQueueFinishSimple) { +TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) { pi_queue queue; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -88,18 +87,18 @@ TEST_F(CudaTestQueue, PIQueueFinishSimple) { // todo: post work on queue, ensure the results are valid and the work is // complete after piQueueFinish? - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); ASSERT_EQ(cuStreamQuery(queue->get()), CUDA_SUCCESS); - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); } -TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) { +TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) { pi_queue queue; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, PI_CUDA_USE_DEFAULT_STREAM, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -110,13 +109,13 @@ TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_DEFAULT); - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); } -TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) { +TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) { pi_queue queue; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, PI_CUDA_SYNC_WITH_DEFAULT, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -127,13 +126,13 @@ TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) { cuStreamGetFlags(stream, &flags); ASSERT_NE(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); } -TEST_F(CudaTestQueue, PICreateQueueInterop) { +TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) { pi_queue queue; - ASSERT_EQ((plugin.call_nocheck( + ASSERT_EQ((Plugins[0].call_nocheck( context_, device_, 0, &queue)), PI_SUCCESS); ASSERT_NE(queue, nullptr); @@ -146,6 +145,6 @@ TEST_F(CudaTestQueue, PICreateQueueInterop) { ASSERT_EQ(res, CUDA_SUCCESS); EXPECT_EQ(cuCtx, context_->get()); - ASSERT_EQ((plugin.call_nocheck(queue)), + ASSERT_EQ((Plugins[0].call_nocheck(queue)), PI_SUCCESS); }