Skip to content

Commit 3075a6f

Browse files
author
Steffen Larsen
committed
[SYCL] Changed CUDA unit tests to call through plugin
Signed-off-by: Steffen Larsen <[email protected]>
1 parent 5724009 commit 3075a6f

File tree

10 files changed

+524
-252
lines changed

10 files changed

+524
-252
lines changed

‎sycl/.clang-format

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,2 +1 @@
11
BasedOnStyle: LLVM
2-
TypenameMacros: ['PI_CALL' ,'PI_CALL_THROW', 'PI_CALL_NOCHECK']

‎sycl/unittests/pi/EnqueueMemTest.cpp

Lines changed: 43 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -7,13 +7,16 @@
77
//===----------------------------------------------------------------------===//
88

99
#include <CL/sycl/detail/pi.hpp>
10+
#include <CL/sycl/detail/plugin.hpp>
1011
#include <gtest/gtest.h>
1112

1213
using namespace cl::sycl;
1314

1415
namespace {
1516
class DISABLED_EnqueueMemTest : public ::testing::Test {
1617
protected:
18+
std::vector<detail::plugin> Plugins;
19+
1720
constexpr static size_t _numElementsX = 8;
1821
constexpr static size_t _numElementsY = 4;
1922

@@ -27,30 +30,42 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
2730
~DISABLED_EnqueueMemTest() = default;
2831

2932
void SetUp() override {
30-
detail::pi::initialize();
33+
Plugins = detail::pi::initialize();
34+
ASSERT_FALSE(Plugins.empty());
3135

3236
pi_platform platform = nullptr;
33-
ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(1, &platform, nullptr)), PI_SUCCESS);
37+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
38+
1, &platform, nullptr)),
39+
PI_SUCCESS);
3440

35-
ASSERT_EQ(
36-
(PI_CALL_NOCHECK(piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
37-
PI_SUCCESS);
41+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
42+
platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
43+
PI_SUCCESS);
3844

3945
pi_result result = PI_INVALID_VALUE;
40-
result = PI_CALL_NOCHECK(piContextCreate)(nullptr, 1u, &_device, nullptr, nullptr, &_context);
46+
result = Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
47+
nullptr, 1u, &_device, nullptr, nullptr, &_context);
4148
ASSERT_EQ(result, PI_SUCCESS);
4249

43-
ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS);
50+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
51+
_context, _device, 0, &_queue)),
52+
PI_SUCCESS);
4453

45-
ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(
46-
_context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
47-
nullptr, &_mem)), PI_SUCCESS);
54+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
55+
_context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
56+
nullptr, &_mem)),
57+
PI_SUCCESS);
4858
}
4959

5060
void TearDown() override {
51-
ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(_mem)), PI_SUCCESS);
52-
ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS);
53-
ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS);
61+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
62+
PI_SUCCESS);
63+
ASSERT_EQ(
64+
(Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
65+
PI_SUCCESS);
66+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
67+
_context)),
68+
PI_SUCCESS);
5469
}
5570

5671
template <typename T> void TestBufferFill(const T &pattern) {
@@ -61,21 +76,24 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
6176
ASSERT_NE(pattern, inValues[i]);
6277
}
6378

64-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_queue, _mem, PI_TRUE, 0,
65-
_numElementsX * sizeof(T),
66-
inValues, 0, nullptr, nullptr)),
67-
PI_SUCCESS);
79+
ASSERT_EQ(
80+
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
81+
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0,
82+
nullptr, nullptr)),
83+
PI_SUCCESS);
6884

69-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferFill)(_queue, _mem, &pattern, sizeof(T), 0,
70-
sizeof(inValues), 0, nullptr,
71-
nullptr)),
72-
PI_SUCCESS);
85+
ASSERT_EQ(
86+
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
87+
_queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr,
88+
nullptr)),
89+
PI_SUCCESS);
7390

7491
T outValues[_numElementsX] = {};
75-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_queue, _mem, PI_TRUE, 0,
76-
_numElementsX * sizeof(T),
77-
outValues, 0, nullptr, nullptr)),
78-
PI_SUCCESS);
92+
ASSERT_EQ(
93+
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
94+
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0,
95+
nullptr, nullptr)),
96+
PI_SUCCESS);
7997

8098
for (size_t i = 0; i < _numElementsX; ++i) {
8199
ASSERT_EQ(pattern, outValues[i]);

‎sycl/unittests/pi/EventTest.cpp

Lines changed: 103 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "CL/sycl/detail/pi.hpp"
10+
#include <CL/sycl/detail/plugin.hpp>
1011
#include <atomic>
1112
#include <gtest/gtest.h>
1213
#include <thread>
@@ -16,6 +17,8 @@ using namespace cl::sycl;
1617
namespace pi {
1718
class DISABLED_EventTest : public ::testing::Test {
1819
protected:
20+
std::vector<detail::plugin> Plugins;
21+
1922
pi_platform _platform;
2023
pi_context _context;
2124
pi_queue _queue;
@@ -25,39 +28,50 @@ class DISABLED_EventTest : public ::testing::Test {
2528
DISABLED_EventTest()
2629
: _context{nullptr}, _queue{nullptr}, _device{nullptr},
2730
_result{PI_INVALID_VALUE} {
28-
detail::pi::initialize();
31+
Plugins = detail::pi::initialize();
2932
}
3033

3134
~DISABLED_EventTest() override = default;
3235

3336
void SetUp() override {
3437
pi_uint32 numPlatforms = 0;
38+
ASSERT_FALSE(Plugins.empty());
3539

36-
ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)),
40+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
41+
0, nullptr, &numPlatforms)),
3742
PI_SUCCESS)
3843
<< "piPlatformsGet failed.\n";
3944

40-
ASSERT_EQ(
41-
(PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &_platform, nullptr)),
42-
PI_SUCCESS)
45+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
46+
numPlatforms, &_platform, nullptr)),
47+
PI_SUCCESS)
4348
<< "piPlatformsGet failed.\n";
4449
(void)numPlatforms; // Deal with unused variable warning
4550

46-
ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
51+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
52+
_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
4753
PI_SUCCESS);
4854

49-
ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS);
55+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
56+
nullptr, 1, &_device, nullptr, nullptr, &_context)),
57+
PI_SUCCESS);
5058

51-
ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS);
59+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
60+
_context, _device, 0, &_queue)),
61+
PI_SUCCESS);
5262

5363
_result = PI_INVALID_VALUE;
5464
}
5565

5666
void TearDown() override {
5767

58-
ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS);
68+
ASSERT_EQ(
69+
(Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
70+
PI_SUCCESS);
5971

60-
ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS);
72+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
73+
_context)),
74+
PI_SUCCESS);
6175
}
6276
};
6377

@@ -66,84 +80,111 @@ class DISABLED_EventTest : public ::testing::Test {
6680

6781
TEST_F(DISABLED_EventTest, PICreateEvent) {
6882
pi_event foo;
69-
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
83+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
84+
&foo)),
85+
PI_SUCCESS);
7086
ASSERT_NE(foo, nullptr);
7187

72-
EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
88+
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
89+
PI_SUCCESS);
7390
}
7491

7592
TEST_F(DISABLED_EventTest, piEventGetInfo) {
7693

7794
pi_event foo;
78-
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
95+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
96+
&foo)),
97+
PI_SUCCESS);
7998
ASSERT_NE(foo, nullptr);
8099

81100
pi_uint64 paramValue = 0;
82101
pi_uint64 retSize = 0;
83-
EXPECT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
84-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
102+
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
103+
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
104+
&paramValue, &retSize)),
105+
PI_SUCCESS);
85106

86107
EXPECT_EQ(retSize, sizeof(pi_int32));
87108
EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED);
88109

89-
EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
110+
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
111+
PI_SUCCESS);
90112
}
91113

92114
TEST_F(DISABLED_EventTest, piEventSetStatus) {
93115

94116
pi_event foo;
95-
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
117+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
118+
&foo)),
119+
PI_SUCCESS);
96120
ASSERT_NE(foo, nullptr);
97121

98122
pi_event_status paramValue = PI_EVENT_QUEUED;
99123
size_t retSize = 0u;
100-
PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
101-
sizeof(paramValue), &paramValue, &retSize);
124+
Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
125+
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
126+
&paramValue, &retSize);
102127

103-
EXPECT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS);
128+
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
129+
foo, PI_EVENT_COMPLETE)),
130+
PI_SUCCESS);
104131

105132
paramValue = {};
106133
retSize = 0u;
107-
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
108-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
134+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
135+
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
136+
&paramValue, &retSize)),
137+
PI_SUCCESS);
109138
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
110139

111-
EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
140+
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
141+
PI_SUCCESS);
112142
}
113143

114144
TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) {
115145

116146
pi_event foo;
117-
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
147+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
148+
&foo)),
149+
PI_SUCCESS);
118150
ASSERT_NE(foo, nullptr);
119151

120152
pi_event_status paramValue = {};
121153
size_t retSize = 0u;
122-
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
123-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
154+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
155+
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
156+
&paramValue, &retSize)),
157+
PI_SUCCESS);
124158
ASSERT_EQ(paramValue, PI_EVENT_SUBMITTED);
125159

126160
std::atomic<bool> started{false};
127161

128162
auto tWaiter = std::thread([&]() {
129163
started = true;
130-
ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &foo)), PI_SUCCESS);
164+
ASSERT_EQ(
165+
(Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &foo)),
166+
PI_SUCCESS);
131167
});
132168

133169
while (!started) {
134170
};
135171

136-
ASSERT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS);
172+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
173+
foo, PI_EVENT_COMPLETE)),
174+
PI_SUCCESS);
137175

138176
tWaiter.join();
139177

140178
paramValue = {};
141179
retSize = 0u;
142-
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
143-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
180+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
181+
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
182+
&paramValue, &retSize)),
183+
PI_SUCCESS);
144184
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
145185

146-
ASSERT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
186+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
187+
PI_SUCCESS);
147188
}
148189

149190
TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
@@ -154,39 +195,56 @@ TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
154195
constexpr const size_t bytes = sizeof(data);
155196

156197
pi_mem memObj;
157-
ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(_context, PI_MEM_FLAGS_ACCESS_RW, bytes,
158-
nullptr, &memObj)), PI_SUCCESS);
198+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
199+
_context, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)),
200+
PI_SUCCESS);
159201

160202
pi_event events[4] = {nullptr, nullptr, nullptr, nullptr};
161203

162-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_queue, memObj, true, 0, bytes, data, 0,
163-
nullptr, &events[0])), PI_SUCCESS);
204+
ASSERT_EQ(
205+
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
206+
_queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])),
207+
PI_SUCCESS);
164208
ASSERT_NE(events[0], nullptr);
165209

166-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_queue, memObj, true, 0, bytes, output,
167-
0, nullptr, &events[1])), PI_SUCCESS);
210+
ASSERT_EQ(
211+
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
212+
_queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])),
213+
PI_SUCCESS);
168214
ASSERT_NE(events[1], nullptr);
169215

170-
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &events[2])), PI_SUCCESS);
216+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(
217+
_context, &events[2])),
218+
PI_SUCCESS);
171219
ASSERT_NE(events[2], nullptr);
172220

173-
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueEventsWait)(_queue, 3, events, &events[3])), PI_SUCCESS);
221+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueEventsWait>(
222+
_queue, 3, events, &events[3])),
223+
PI_SUCCESS);
174224
ASSERT_NE(events[3], nullptr);
175225

176226
pi_event_status paramValue = {};
177227
size_t retSize = 0u;
178-
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
179-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
228+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
229+
events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
230+
sizeof(paramValue), &paramValue, &retSize)),
231+
PI_SUCCESS);
180232
ASSERT_NE(paramValue, PI_EVENT_COMPLETE);
181233

182-
ASSERT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(events[2], PI_EVENT_COMPLETE)), PI_SUCCESS);
234+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
235+
events[2], PI_EVENT_COMPLETE)),
236+
PI_SUCCESS);
183237

184-
ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &events[3])), PI_SUCCESS);
238+
ASSERT_EQ(
239+
(Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &events[3])),
240+
PI_SUCCESS);
185241

186242
paramValue = {};
187243
retSize = 0u;
188-
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
189-
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
244+
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
245+
events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
246+
sizeof(paramValue), &paramValue, &retSize)),
247+
PI_SUCCESS);
190248
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
191249
}
192250

0 commit comments

Comments
 (0)