From 3075a6f7b811f7c75ec554fc9701209a729419c9 Mon Sep 17 00:00:00 2001 From: Steffen Larsen Date: Wed, 12 Feb 2020 16:52:30 +0000 Subject: [PATCH] [SYCL] Changed CUDA unit tests to call through plugin Signed-off-by: Steffen Larsen --- sycl/.clang-format | 1 - sycl/unittests/pi/EnqueueMemTest.cpp | 68 +++--- sycl/unittests/pi/EventTest.cpp | 148 +++++++++---- sycl/unittests/pi/cuda/test_base_objects.cpp | 69 ++++-- sycl/unittests/pi/cuda/test_commands.cpp | 68 ++++-- sycl/unittests/pi/cuda/test_device.cpp | 51 +++-- sycl/unittests/pi/cuda/test_events.cpp | 46 ++-- sycl/unittests/pi/cuda/test_kernels.cpp | 220 +++++++++++++------ sycl/unittests/pi/cuda/test_mem_obj.cpp | 42 ++-- sycl/unittests/pi/cuda/test_queue.cpp | 63 ++++-- 10 files changed, 524 insertions(+), 252 deletions(-) diff --git a/sycl/.clang-format b/sycl/.clang-format index 0b8fc6ba0d58..9b3aa8b7213b 100644 --- a/sycl/.clang-format +++ b/sycl/.clang-format @@ -1,2 +1 @@ BasedOnStyle: LLVM -TypenameMacros: ['PI_CALL' ,'PI_CALL_THROW', 'PI_CALL_NOCHECK'] diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp index 7381a4524a83..6226fd2b53d2 100644 --- a/sycl/unittests/pi/EnqueueMemTest.cpp +++ b/sycl/unittests/pi/EnqueueMemTest.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include +#include #include using namespace cl::sycl; @@ -14,6 +15,8 @@ using namespace cl::sycl; namespace { class DISABLED_EnqueueMemTest : public ::testing::Test { protected: + std::vector Plugins; + constexpr static size_t _numElementsX = 8; constexpr static size_t _numElementsY = 4; @@ -27,30 +30,42 @@ class DISABLED_EnqueueMemTest : public ::testing::Test { ~DISABLED_EnqueueMemTest() = default; void SetUp() override { - detail::pi::initialize(); + Plugins = detail::pi::initialize(); + ASSERT_FALSE(Plugins.empty()); pi_platform platform = nullptr; - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(1, &platform, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + 1, &platform, nullptr)), + PI_SUCCESS); - ASSERT_EQ( - (PI_CALL_NOCHECK(piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), - PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), + PI_SUCCESS); pi_result result = PI_INVALID_VALUE; - result = PI_CALL_NOCHECK(piContextCreate)(nullptr, 1u, &_device, nullptr, nullptr, &_context); + result = Plugins[0].call_nocheck( + nullptr, 1u, &_device, nullptr, nullptr, &_context); ASSERT_EQ(result, PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context, _device, 0, &_queue)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)( - _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32), - nullptr, &_mem)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32), + nullptr, &_mem)), + PI_SUCCESS); } void TearDown() override { - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(_mem)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_mem)), + PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(_queue)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context)), + PI_SUCCESS); } template void TestBufferFill(const T &pattern) { @@ -61,21 +76,24 @@ class DISABLED_EnqueueMemTest : public ::testing::Test { ASSERT_NE(pattern, inValues[i]); } - ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_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((PI_CALL_NOCHECK(piEnqueueMemBufferFill)(_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((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_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]); diff --git a/sycl/unittests/pi/EventTest.cpp b/sycl/unittests/pi/EventTest.cpp index 4c5e44dc9da7..0c8b55dca286 100644 --- a/sycl/unittests/pi/EventTest.cpp +++ b/sycl/unittests/pi/EventTest.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "CL/sycl/detail/pi.hpp" +#include #include #include #include @@ -16,6 +17,8 @@ using namespace cl::sycl; namespace pi { class DISABLED_EventTest : public ::testing::Test { protected: + std::vector Plugins; + pi_platform _platform; pi_context _context; pi_queue _queue; @@ -25,39 +28,50 @@ class DISABLED_EventTest : public ::testing::Test { DISABLED_EventTest() : _context{nullptr}, _queue{nullptr}, _device{nullptr}, _result{PI_INVALID_VALUE} { - detail::pi::initialize(); + Plugins = detail::pi::initialize(); } ~DISABLED_EventTest() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &_platform, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &_platform, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; (void)numPlatforms; // Deal with unused variable warning - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), + ASSERT_EQ((Plugins[0].call_nocheck( + _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &_device, nullptr, nullptr, &_context)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context, _device, 0, &_queue)), + PI_SUCCESS); _result = PI_INVALID_VALUE; } void TearDown() override { - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(_queue)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context)), + PI_SUCCESS); } }; @@ -66,84 +80,111 @@ class DISABLED_EventTest : public ::testing::Test { TEST_F(DISABLED_EventTest, PICreateEvent) { pi_event foo; - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(_context, + &foo)), + PI_SUCCESS); ASSERT_NE(foo, nullptr); - EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + EXPECT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } TEST_F(DISABLED_EventTest, piEventGetInfo) { pi_event foo; - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_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((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + EXPECT_EQ((Plugins[0].call_nocheck( + foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), + ¶mValue, &retSize)), + PI_SUCCESS); EXPECT_EQ(retSize, sizeof(pi_int32)); EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED); - EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + EXPECT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } TEST_F(DISABLED_EventTest, piEventSetStatus) { pi_event foo; - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_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; - PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize); + Plugins[0].call_nocheck( + foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), + ¶mValue, &retSize); - EXPECT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS); + EXPECT_EQ((Plugins[0].call_nocheck( + foo, PI_EVENT_COMPLETE)), + PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + 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((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + EXPECT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) { pi_event foo; - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_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((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), + ¶mValue, &retSize)), + PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_SUBMITTED); std::atomic started{false}; auto tWaiter = std::thread([&]() { started = true; - ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &foo)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(1, &foo)), + PI_SUCCESS); }); while (!started) { }; - ASSERT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + foo, PI_EVENT_COMPLETE)), + PI_SUCCESS); tWaiter.join(); paramValue = {}; retSize = 0u; - ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + 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((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } TEST_F(DISABLED_EventTest, piEnqueueEventsWait) { @@ -154,39 +195,56 @@ TEST_F(DISABLED_EventTest, piEnqueueEventsWait) { constexpr const size_t bytes = sizeof(data); pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(_context, PI_MEM_FLAGS_ACCESS_RW, bytes, - nullptr, &memObj)), PI_SUCCESS); + 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((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_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((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_queue, memObj, true, 0, bytes, output, - 0, nullptr, &events[1])), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + _queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])), + PI_SUCCESS); ASSERT_NE(events[1], nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &events[2])), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context, &events[2])), + PI_SUCCESS); ASSERT_NE(events[2], nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueEventsWait)(_queue, 3, events, &events[3])), PI_SUCCESS); + 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((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + 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((PI_CALL_NOCHECK(piEventSetStatus)(events[2], PI_EVENT_COMPLETE)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + events[2], PI_EVENT_COMPLETE)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &events[3])), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(1, &events[3])), + PI_SUCCESS); paramValue = {}; retSize = 0u; - ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, + sizeof(paramValue), ¶mValue, &retSize)), + PI_SUCCESS); ASSERT_EQ(paramValue, PI_EVENT_COMPLETE); } diff --git a/sycl/unittests/pi/cuda/test_base_objects.cpp b/sycl/unittests/pi/cuda/test_base_objects.cpp index 32238dbda530..c553e45e0c54 100644 --- a/sycl/unittests/pi/cuda/test_base_objects.cpp +++ b/sycl/unittests/pi/cuda/test_base_objects.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include @@ -22,8 +23,9 @@ using namespace cl::sycl; class DISABLED_CudaBaseObjectsTest : public ::testing::Test { protected: + std::vector Plugins; - DISABLED_CudaBaseObjectsTest() { detail::pi::initialize(); } + DISABLED_CudaBaseObjectsTest() { Plugins = detail::pi::initialize(); } ~DISABLED_CudaBaseObjectsTest() = default; }; @@ -32,24 +34,31 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) { pi_uint32 numPlatforms = 0; pi_platform platform = nullptr; pi_device device; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; ASSERT_GE(numPlatforms, 1u); ASSERT_NE(platform, nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), - PI_SUCCESS) << "piDevicesGet failed.\n"; + 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((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS) << "piContextCreate failed.\n"; + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device, nullptr, nullptr, &ctxt)), + PI_SUCCESS) + << "piContextCreate failed.\n"; EXPECT_NE(ctxt, nullptr); EXPECT_EQ(ctxt->get_device(), device); @@ -69,21 +78,25 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimary) { pi_platform platform; pi_device device; - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), + PI_SUCCESS); cl_context_properties properties = PI_CONTEXT_PROPERTIES_CUDA_PRIMARY; pi_context ctxt; - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(&properties, 1, &device, nullptr, nullptr, - &ctxt)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + &properties, 1, &device, nullptr, nullptr, &ctxt)), + PI_SUCCESS); EXPECT_NE(ctxt, nullptr); EXPECT_EQ(ctxt->get_device(), device); EXPECT_TRUE(ctxt->is_primary()); @@ -100,7 +113,9 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimary) { cuErr = cuCtxGetCurrent(¤t); ASSERT_EQ(cuErr, CUDA_SUCCESS); ASSERT_EQ(current, cudaContext); - ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(ctxt)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck(ctxt)), + PI_SUCCESS); } TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { @@ -108,20 +123,24 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { pi_platform platform; pi_device device; - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK( - piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)), + PI_SUCCESS); pi_context ctxt; - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device, nullptr, nullptr, &ctxt)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device, nullptr, nullptr, &ctxt)), + PI_SUCCESS); EXPECT_NE(ctxt, nullptr); // Retrieve the cuCtxt to check information is correct @@ -150,5 +169,7 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) { callContextFromOtherThread.join(); - ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(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 586721701028..1056be8e894d 100644 --- a/sycl/unittests/pi/cuda/test_commands.cpp +++ b/sycl/unittests/pi/cuda/test_commands.cpp @@ -12,6 +12,7 @@ #include #include +#include #include using namespace cl::sycl; @@ -19,6 +20,8 @@ using namespace cl::sycl; struct DISABLED_CudaCommandsTest : public ::testing::Test { protected: + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; @@ -27,33 +30,40 @@ struct DISABLED_CudaCommandsTest : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform_, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform_, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform_, PI_DEVICE_TYPE_GPU, 1, - &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device_, nullptr, nullptr, &context_)), + PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, 0, &queue_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, 0, &queue_)), + PI_SUCCESS); ASSERT_NE(queue_, nullptr); auto tmpCtxt = queue_->get_context(); ASSERT_EQ(tmpCtxt, context_); } void TearDown() override { - PI_CALL(piQueueRelease)(queue_); - PI_CALL(piContextRelease)(context_); + Plugins[0].call(queue_); + Plugins[0].call(context_); } - DISABLED_CudaCommandsTest() { detail::pi::initialize(); } + DISABLED_CudaCommandsTest() { Plugins = detail::pi::initialize(); } ~DISABLED_CudaCommandsTest() = default; }; @@ -65,14 +75,18 @@ TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferBlocking) { int output[memSize] = {}; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - bytes, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)( - 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((PI_CALL_NOCHECK(piEnqueueMemBufferRead)( - queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)), + PI_SUCCESS); bool isSame = std::equal(std::begin(output), std::end(output), std::begin(data)); @@ -91,19 +105,25 @@ TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferNonBlocking) { int output[memSize] = {}; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - bytes, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)), + PI_SUCCESS); pi_event cpIn, cpOut; - ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(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((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(queue_, memObj, false, 0, bytes, output, 0, - nullptr, &cpOut)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + queue_, memObj, false, 0, bytes, output, 0, nullptr, &cpOut)), + PI_SUCCESS); ASSERT_NE(cpOut, nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(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 e74a34024afd..b434e54b79bf 100644 --- a/sycl/unittests/pi/cuda/test_device.cpp +++ b/sycl/unittests/pi/cuda/test_device.cpp @@ -12,6 +12,7 @@ #include #include +#include #include using namespace cl::sycl; @@ -19,30 +20,38 @@ using namespace cl::sycl; struct DISABLED_CudaDeviceTests : public ::testing::Test { protected: + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform_, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform_, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device_, nullptr, nullptr, &context_)), + PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - PI_CALL(piDeviceRelease)(device_); - PI_CALL(piContextRelease)(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } DISABLED_CudaDeviceTests() { detail::pi::initialize(); } @@ -54,31 +63,39 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) { size_t return_size = 0; pi_device_type device_type; - ASSERT_EQ((PI_CALL_NOCHECK(piDeviceGetInfo)(device_, PI_DEVICE_INFO_TYPE, sizeof(pi_device_type), - &device_type, &return_size)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + device_, PI_DEVICE_INFO_TYPE, sizeof(pi_device_type), + &device_type, &return_size)), + PI_SUCCESS); EXPECT_EQ(return_size, sizeof(pi_device_type)); EXPECT_EQ( device_type, PI_DEVICE_TYPE_GPU); // backend pre-defined value, device must be a GPU pi_device parent_device = nullptr; - ASSERT_EQ((PI_CALL_NOCHECK(piDeviceGetInfo)(device_, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(pi_device), - &parent_device, &return_size)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + device_, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(pi_device), + &parent_device, &return_size)), + PI_SUCCESS); EXPECT_EQ(return_size, sizeof(pi_device)); EXPECT_EQ(parent_device, nullptr); // backend pre-set value, device cannot have a parent pi_platform platform = nullptr; - ASSERT_EQ((PI_CALL_NOCHECK(piDeviceGetInfo)(device_, PI_DEVICE_INFO_PLATFORM, sizeof(pi_platform), - &platform, &return_size)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + device_, PI_DEVICE_INFO_PLATFORM, sizeof(pi_platform), + &platform, &return_size)), + PI_SUCCESS); EXPECT_EQ(return_size, sizeof(pi_platform)); EXPECT_EQ(platform, platform_); // test fixture device was created from the // test fixture platform cl_device_partition_property device_partition_property = -1; - ASSERT_EQ((PI_CALL_NOCHECK(piDeviceGetInfo)(device_, PI_DEVICE_INFO_PARTITION_TYPE, - sizeof(cl_device_partition_property), - &device_partition_property, &return_size)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + device_, PI_DEVICE_INFO_PARTITION_TYPE, + sizeof(cl_device_partition_property), + &device_partition_property, &return_size)), + PI_SUCCESS); EXPECT_EQ(device_partition_property, 0); // PI CUDA backend will not support device partitioning, this // function should just return 0. diff --git a/sycl/unittests/pi/cuda/test_events.cpp b/sycl/unittests/pi/cuda/test_events.cpp index 89f0da39eabf..932abcb77e78 100644 --- a/sycl/unittests/pi/cuda/test_events.cpp +++ b/sycl/unittests/pi/cuda/test_events.cpp @@ -12,6 +12,7 @@ #include #include +#include #include #include @@ -20,6 +21,8 @@ using namespace cl::sycl; namespace pi { class DISABLED_CudaEventTests : public ::testing::Test { protected: + std::vector Plugins; + pi_platform _platform; pi_context _context; pi_queue _queue; @@ -27,45 +30,55 @@ class DISABLED_CudaEventTests : public ::testing::Test { DISABLED_CudaEventTests() : _context{nullptr}, _queue{nullptr}, _device{nullptr} { - detail::pi::initialize(); + Plugins = detail::pi::initialize(); } ~DISABLED_CudaEventTests() override = default; void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &_platform, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &_platform, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), + ASSERT_EQ((Plugins[0].call_nocheck( + _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &_device, nullptr, nullptr, &_context)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + _context, _device, 0, &_queue)), + PI_SUCCESS); } void TearDown() override { - PI_CALL(piQueueRelease)(_queue); - PI_CALL(piContextRelease)(_context); + Plugins[0].call(_queue); + Plugins[0].call(_context); } }; TEST_F(DISABLED_CudaEventTests, PICreateEvent) { pi_event foo; - ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_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((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) { @@ -75,8 +88,10 @@ TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) { pi_event_status paramValue = {}; size_t retSize = 0u; - ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(paramValue), ¶mValue, &retSize)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue), + ¶mValue, &retSize)), + PI_SUCCESS); EXPECT_EQ(retSize, sizeof(pi_int32)); EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED); @@ -86,6 +101,7 @@ TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) { auto errCode = cuEventQuery(cuEvent); ASSERT_EQ(errCode, CUDA_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(foo)), + PI_SUCCESS); } } // namespace pi diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp index 00183515324e..0758e64c69d8 100644 --- a/sycl/unittests/pi/cuda/test_kernels.cpp +++ b/sycl/unittests/pi/cuda/test_kernels.cpp @@ -12,6 +12,7 @@ #include #include +#include #include using namespace cl::sycl; @@ -19,6 +20,8 @@ using namespace cl::sycl; struct DISABLED_CudaKernelsTest : public ::testing::Test { protected: + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; @@ -26,33 +29,40 @@ struct DISABLED_CudaKernelsTest : public ::testing::Test { void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform_, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform_, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK( - piContextCreate)(nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device_, nullptr, nullptr, &context_)), + PI_SUCCESS); ASSERT_NE(context_, nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, 0, &queue_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, 0, &queue_)), + PI_SUCCESS); ASSERT_NE(queue_, nullptr); ASSERT_EQ(queue_->get_context(), context_); } void TearDown() override { - PI_CALL(piDeviceRelease)(device_); - PI_CALL(piQueueRelease)(queue_); - PI_CALL(piContextRelease)(context_); + Plugins[0].call(device_); + Plugins[0].call(queue_); + Plugins[0].call(context_); } - DISABLED_CudaKernelsTest() { detail::pi::initialize(); } + DISABLED_CudaKernelsTest() { Plugins = detail::pi::initialize(); } ~DISABLED_CudaKernelsTest() = default; }; @@ -120,29 +130,43 @@ const char *threeParamsTwoLocal = "\n\ TEST_F(DISABLED_CudaKernelsTest, PICreateProgramAndKernel) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&ptxSource, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "_Z8myKernelPi", &kern)), + PI_SUCCESS); ASSERT_NE(kern, nullptr); } TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&ptxSource, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "_Z8myKernelPi", &kern)), + PI_SUCCESS); int number = 10; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 0, sizeof(int), &number)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 0, sizeof(int), &number)), + PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); ASSERT_EQ(kernArgs.size(), (size_t)1); int storedValue = *(static_cast(kernArgs[0])); @@ -152,23 +176,33 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) { TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&ptxSource, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "_Z8myKernelPi", &kern)), + PI_SUCCESS); int number = 10; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 0, sizeof(int), &number)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 0, sizeof(int), &number)), + PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); ASSERT_GT(kernArgs.size(), (size_t)0); int storedValue = *(static_cast(kernArgs[0])); ASSERT_EQ(storedValue, number); int otherNumber = 934; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 0, sizeof(int), &otherNumber)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 0, sizeof(int), &otherNumber)), + PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); ASSERT_EQ(kernArgs2.size(), (size_t)1); storedValue = *(static_cast(kernArgs2[0])); @@ -178,20 +212,29 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) { TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&ptxSource, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "_Z8myKernelPi", &kern)), + PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - memSize, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 0, sizeof(pi_mem), &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 0, sizeof(pi_mem), &memObj)), + PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); ASSERT_EQ(kernArgs.size(), (size_t)1); pi_mem storedValue = *(static_cast(kernArgs[0])); @@ -201,66 +244,95 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) { TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatch) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&ptxSource, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&ptxSource, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "_Z8myKernelPi", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "_Z8myKernelPi", &kern)), + PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - memSize, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piextKernelSetArgMemObj)(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((PI_CALL_NOCHECK(piEnqueueKernelLaunch)(queue_, kern, workDim, globalWorkOffset, - globalWorkSize, localWorkSize, 0, nullptr, - nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + queue_, kern, workDim, globalWorkOffset, globalWorkSize, + localWorkSize, 0, nullptr, nullptr)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + PI_SUCCESS); } TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&twoParams, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&twoParams, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "twoParamKernel", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "twoParamKernel", &kern)), + PI_SUCCESS); size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - memSize, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), + PI_SUCCESS); pi_mem memObj2; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - memSize, nullptr, &memObj2)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piextKernelSetArgMemObj)(kern, 0, &memObj)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + kern, 0, &memObj)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piextKernelSetArgMemObj)(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((PI_CALL_NOCHECK(piEnqueueKernelLaunch)(queue_, kern, workDim, globalWorkOffset, - globalWorkSize, localWorkSize, 0, nullptr, - nullptr)), PI_SUCCESS); - - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(memObj)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(memObj2)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + queue_, kern, workDim, globalWorkOffset, globalWorkSize, + localWorkSize, 0, nullptr, nullptr)), + PI_SUCCESS); + + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(memObj2)), + PI_SUCCESS); } @@ -268,28 +340,40 @@ TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) { TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) { pi_program prog; - ASSERT_EQ((PI_CALL_NOCHECK(piclProgramCreateWithSource)( - context_, 1, (const char **)&threeParamsTwoLocal, nullptr, &prog)), PI_SUCCESS); + ASSERT_EQ( + (Plugins[0].call_nocheck( + context_, 1, (const char **)&threeParamsTwoLocal, nullptr, &prog)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piProgramBuild)(prog, 1, &device_, "", nullptr, nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, 1, &device_, "", nullptr, nullptr)), + PI_SUCCESS); pi_kernel kern; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelCreate)(prog, "twoParamKernelLocal", &kern)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + prog, "twoParamKernelLocal", &kern)), + PI_SUCCESS); int number = 10; - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 0, sizeof(int), &number)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 0, sizeof(int), &number)), + PI_SUCCESS); const auto &kernArgs = kern->get_arg_indices(); ASSERT_GT(kernArgs.size(), (size_t)0); int storedValue = *(static_cast(kernArgs[0])); ASSERT_EQ(storedValue, number); - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 1, sizeof(int), nullptr)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + kern, 1, sizeof(int), nullptr)), + PI_SUCCESS); const auto &kernArgs2 = kern->get_arg_indices(); ASSERT_EQ(kernArgs2.size(), (size_t)2); storedValue = *(static_cast(kernArgs2[1])); ASSERT_EQ(storedValue, 0); - ASSERT_EQ((PI_CALL_NOCHECK(piKernelSetArg)(kern, 2, sizeof(int), nullptr)), PI_SUCCESS); + 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])); diff --git a/sycl/unittests/pi/cuda/test_mem_obj.cpp b/sycl/unittests/pi/cuda/test_mem_obj.cpp index 7ffce4f40f5a..6af79b47968e 100644 --- a/sycl/unittests/pi/cuda/test_mem_obj.cpp +++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include using namespace cl::sycl; @@ -20,6 +21,8 @@ using namespace cl::sycl; struct DISABLED_CudaTestMemObj : public ::testing::Test { protected: + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; @@ -27,27 +30,33 @@ struct DISABLED_CudaTestMemObj : public ::testing::Test { void SetUp() override { cuCtxSetCurrent(nullptr); pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform_, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform_, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device_, nullptr, nullptr, &context_)), + PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - PI_CALL(piDeviceRelease)(device_); - PI_CALL(piContextRelease)(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } - DISABLED_CudaTestMemObj() { detail::pi::initialize(); } + DISABLED_CudaTestMemObj() { Plugins = detail::pi::initialize(); } ~DISABLED_CudaTestMemObj() = default; }; @@ -55,9 +64,12 @@ struct DISABLED_CudaTestMemObj : public ::testing::Test { TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateSimple) { const size_t memSize = 1024u; pi_mem memObj; - ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), + PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + PI_SUCCESS); } TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateNoActiveContext) { @@ -80,9 +92,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((PI_CALL_NOCHECK(piMemBufferCreate)(context_, PI_MEM_FLAGS_ACCESS_RW, - memSize, nullptr, &memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)), + PI_SUCCESS); ASSERT_NE(memObj, nullptr); - ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(memObj)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(memObj)), + PI_SUCCESS); } diff --git a/sycl/unittests/pi/cuda/test_queue.cpp b/sycl/unittests/pi/cuda/test_queue.cpp index 529a5280c62b..be3ca210e333 100644 --- a/sycl/unittests/pi/cuda/test_queue.cpp +++ b/sycl/unittests/pi/cuda/test_queue.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include using namespace cl::sycl; @@ -20,30 +21,38 @@ using namespace cl::sycl; struct DISABLED_CudaTestQueue : public ::testing::Test { protected: + std::vector Plugins; + pi_platform platform_; pi_device device_; pi_context context_; void SetUp() override { pi_uint32 numPlatforms = 0; + ASSERT_FALSE(Plugins.empty()); - ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)), + ASSERT_EQ((Plugins[0].call_nocheck( + 0, nullptr, &numPlatforms)), PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ( - (PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &platform_, nullptr)), - PI_SUCCESS) + ASSERT_EQ((Plugins[0].call_nocheck( + numPlatforms, &platform_, nullptr)), + PI_SUCCESS) << "piPlatformsGet failed.\n"; - ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), PI_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &device_, nullptr, nullptr, &context_)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)), + PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + nullptr, 1, &device_, nullptr, nullptr, &context_)), + PI_SUCCESS); EXPECT_NE(context_, nullptr); } void TearDown() override { - PI_CALL(piDeviceRelease)(device_); - PI_CALL(piContextRelease)(context_); + Plugins[0].call(device_); + Plugins[0].call(context_); } DISABLED_CudaTestQueue() { detail::pi::initialize(); } @@ -53,7 +62,9 @@ struct DISABLED_CudaTestQueue : public ::testing::Test { TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) { pi_queue queue; - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, 0, &queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, 0, &queue)), + PI_SUCCESS); ASSERT_NE(queue, nullptr); EXPECT_EQ(queue->get_context(), context_); @@ -62,27 +73,34 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); } TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) { pi_queue queue; - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, 0, &queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, 0, &queue)), + PI_SUCCESS); ASSERT_NE(queue, nullptr); // todo: post work on queue, ensure the results are valid and the work is // complete after piQueueFinish? - ASSERT_EQ((PI_CALL_NOCHECK(piQueueFinish)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); ASSERT_EQ(cuStreamQuery(queue->get()), CUDA_SUCCESS); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); } TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) { pi_queue queue; - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, PI_CUDA_USE_DEFAULT_STREAM, &queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, PI_CUDA_USE_DEFAULT_STREAM, &queue)), + PI_SUCCESS); ASSERT_NE(queue, nullptr); EXPECT_EQ(queue->get_context(), context_); @@ -91,12 +109,15 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) { cuStreamGetFlags(stream, &flags); ASSERT_EQ(flags, CU_STREAM_DEFAULT); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); } TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) { pi_queue queue; - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, PI_CUDA_SYNC_WITH_DEFAULT, &queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, PI_CUDA_SYNC_WITH_DEFAULT, &queue)), + PI_SUCCESS); ASSERT_NE(queue, nullptr); EXPECT_EQ(queue->get_context(), context_); @@ -105,12 +126,15 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) { cuStreamGetFlags(stream, &flags); ASSERT_NE(flags, CU_STREAM_NON_BLOCKING); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); } TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) { pi_queue queue; - ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(context_, device_, 0, &queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck( + context_, device_, 0, &queue)), + PI_SUCCESS); ASSERT_NE(queue, nullptr); EXPECT_EQ(queue->get_context(), context_); @@ -121,5 +145,6 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) { ASSERT_EQ(res, CUDA_SUCCESS); EXPECT_EQ(cuCtx, context_->get()); - ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(queue)), PI_SUCCESS); + ASSERT_EQ((Plugins[0].call_nocheck(queue)), + PI_SUCCESS); }