Skip to content

Commit 98119bd

Browse files
nyallocnyalloc
authored
[SYCL] Enable PI unit testing on multiple plugins. (#1647)
- Backend agnostic PI tests are parameterised by PI Plugin. - Enable CUDA + OpenCL PI unit tests. - Print PI API backend name when running tests - Documented pi_device_type Signed-off-by: Stuart Adams <[email protected]>
1 parent bce2da2 commit 98119bd

18 files changed

+478
-406
lines changed

‎sycl/include/CL/sycl/detail/pi.h

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -133,9 +133,16 @@ typedef enum {
133133
// make the translation to OpenCL transparent.
134134
//
135135
typedef enum : pi_uint64 {
136-
PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU,
137-
PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU,
138-
PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR
136+
PI_DEVICE_TYPE_DEFAULT =
137+
CL_DEVICE_TYPE_DEFAULT, ///< The default device available in the PI
138+
///< plugin.
139+
PI_DEVICE_TYPE_ALL =
140+
CL_DEVICE_TYPE_ALL, ///< All devices available in the PI plugin.
141+
PI_DEVICE_TYPE_CPU =
142+
CL_DEVICE_TYPE_CPU, ///< A PI device that is the host processor.
143+
PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, ///< A PI device that is a GPU.
144+
PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR ///< A PI device that is a
145+
///< dedicated accelerator.
139146
} _pi_device_type;
140147

141148
typedef enum {

‎sycl/plugins/cuda/pi_cuda.cpp

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -716,15 +716,18 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type,
716716
pi_uint32 *num_devices) {
717717

718718
pi_result err = PI_SUCCESS;
719-
const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU);
720-
size_t numDevices = askingForGPU ? platform->devices_.size() : 0;
719+
const bool askingForDefault = device_type == PI_DEVICE_TYPE_DEFAULT;
720+
const bool askingForGPU = device_type & PI_DEVICE_TYPE_GPU;
721+
const bool returnDevices = askingForDefault || askingForGPU;
722+
723+
size_t numDevices = returnDevices ? platform->devices_.size() : 0;
721724

722725
try {
723726
if (num_devices) {
724727
*num_devices = numDevices;
725728
}
726729

727-
if (askingForGPU && devices) {
730+
if (returnDevices && devices) {
728731
for (size_t i = 0; i < std::min(size_t(num_entries), numDevices); ++i) {
729732
devices[i] = platform->devices_[i].get();
730733
}

‎sycl/unittests/pi/BackendString.hpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
2+
// See https://llvm.org/LICENSE.txt for license information.
3+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4+
5+
#pragma once
6+
7+
#include <detail/plugin.hpp>
8+
9+
namespace pi {
10+
inline const char *GetBackendString(cl::sycl::backend backend) {
11+
switch (backend) {
12+
#define PI_BACKEND_STR(backend_name) \
13+
case cl::sycl::backend::backend_name: \
14+
return #backend_name
15+
PI_BACKEND_STR(cuda);
16+
PI_BACKEND_STR(host);
17+
PI_BACKEND_STR(opencl);
18+
#undef PI_BACKEND_STR
19+
default:
20+
return "Unknown Plugin";
21+
}
22+
}
23+
} // namespace pi

‎sycl/unittests/pi/CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ set(CMAKE_CXX_EXTENSIONS OFF)
22

33
# Enable exception handling for these unit tests
44
set(LLVM_REQUIRES_EH 1)
5-
add_sycl_unittest(PiTests OBJECT
5+
add_sycl_unittest(PiTests OBJECT
66
EnqueueMemTest.cpp
77
PiMock.cpp
88
PlatformTest.cpp

‎sycl/unittests/pi/EnqueueMemTest.cpp

Lines changed: 59 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -6,17 +6,16 @@
66
//
77
//===----------------------------------------------------------------------===//
88

9+
#include "BackendString.hpp"
910
#include <CL/sycl/detail/pi.hpp>
1011
#include <detail/plugin.hpp>
1112
#include <gtest/gtest.h>
1213

1314
using namespace cl::sycl;
1415

1516
namespace {
16-
class DISABLED_EnqueueMemTest : public ::testing::Test {
17+
class EnqueueMemTest : public testing::TestWithParam<detail::plugin> {
1718
protected:
18-
std::vector<detail::plugin> Plugins;
19-
2019
constexpr static size_t _numElementsX = 8;
2120
constexpr static size_t _numElementsY = 4;
2221

@@ -25,124 +24,125 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
2524
pi_queue _queue = nullptr;
2625
pi_mem _mem = nullptr;
2726

28-
DISABLED_EnqueueMemTest() = default;
27+
EnqueueMemTest() = default;
2928

30-
~DISABLED_EnqueueMemTest() = default;
29+
~EnqueueMemTest() = default;
3130

3231
void SetUp() override {
33-
Plugins = detail::pi::initialize();
34-
ASSERT_FALSE(Plugins.empty());
32+
33+
detail::plugin plugin = GetParam();
3534

3635
pi_platform platform = nullptr;
37-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
36+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
3837
1, &platform, nullptr)),
3938
PI_SUCCESS);
4039

41-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
42-
platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
40+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
41+
platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)),
4342
PI_SUCCESS);
4443

4544
pi_result result = PI_INVALID_VALUE;
46-
result = Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
45+
result = plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
4746
nullptr, 1u, &_device, nullptr, nullptr, &_context);
4847
ASSERT_EQ(result, PI_SUCCESS);
4948

50-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
49+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
5150
_context, _device, 0, &_queue)),
5251
PI_SUCCESS);
5352

54-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
53+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
5554
_context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
5655
nullptr, &_mem)),
5756
PI_SUCCESS);
5857
}
5958

6059
void TearDown() override {
61-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
60+
61+
detail::plugin plugin = GetParam();
62+
63+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
64+
PI_SUCCESS);
65+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
6266
PI_SUCCESS);
6367
ASSERT_EQ(
64-
(Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
68+
(plugin.call_nocheck<detail::PiApiKind::piContextRelease>(_context)),
6569
PI_SUCCESS);
66-
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
67-
_context)),
68-
PI_SUCCESS);
6970
}
7071

7172
template <typename T> void TestBufferFill(const T &pattern) {
7273

74+
detail::plugin plugin = GetParam();
75+
7376
T inValues[_numElementsX] = {};
7477

7578
for (size_t i = 0; i < _numElementsX; ++i) {
7679
ASSERT_NE(pattern, inValues[i]);
7780
}
7881

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);
82+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
83+
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues,
84+
0, nullptr, nullptr)),
85+
PI_SUCCESS);
8486

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);
87+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
88+
_queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0,
89+
nullptr, nullptr)),
90+
PI_SUCCESS);
9091

9192
T outValues[_numElementsX] = {};
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);
93+
ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
94+
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T),
95+
outValues, 0, nullptr, nullptr)),
96+
PI_SUCCESS);
9797

9898
for (size_t i = 0; i < _numElementsX; ++i) {
9999
ASSERT_EQ(pattern, outValues[i]);
100100
}
101101
}
102102
};
103103

104-
template<typename T>
105-
struct vec4 {
104+
static std::vector<detail::plugin> Plugins = detail::pi::initialize();
105+
106+
INSTANTIATE_TEST_CASE_P(
107+
EnqueueMemTestImpl, EnqueueMemTest, testing::ValuesIn(Plugins),
108+
[](const testing::TestParamInfo<EnqueueMemTest::ParamType> &info) {
109+
return pi::GetBackendString(info.param.getBackend());
110+
});
111+
112+
template <typename T> struct vec4 {
106113
T x, y, z, w;
107114

108115
bool operator==(const vec4 &rhs) const {
109116
return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
110117
}
111118

112-
bool operator!=(const vec4 &rhs) const {
113-
return !(*this == rhs);
114-
}
119+
bool operator!=(const vec4 &rhs) const { return !(*this == rhs); }
115120
};
116121

117-
template<typename T>
118-
struct vec2 {
122+
template <typename T> struct vec2 {
119123
T x, y;
120124

121-
bool operator==(const vec2 &rhs) const {
122-
return x == rhs.x && y == rhs.y;
123-
}
125+
bool operator==(const vec2 &rhs) const { return x == rhs.x && y == rhs.y; }
124126

125-
bool operator!=(const vec2 &rhs) const {
126-
return !(*this == rhs);
127-
}
127+
bool operator!=(const vec2 &rhs) const { return !(*this == rhs); }
128128
};
129129

130-
TEST_F(DISABLED_EnqueueMemTest, piEnqueueMemBufferFill) {
130+
TEST_P(EnqueueMemTest, piEnqueueMemBufferFill) {
131131

132-
TestBufferFill(float{1});
133-
TestBufferFill(vec2<float>{1, 2});
134-
TestBufferFill(vec4<float>{1, 2, 3, 4});
132+
TestBufferFill(float{1});
133+
TestBufferFill(vec2<float>{1, 2});
134+
TestBufferFill(vec4<float>{1, 2, 3, 4});
135135

136-
TestBufferFill(uint8_t{1});
137-
TestBufferFill(vec2<uint8_t>{1, 2});
138-
TestBufferFill(vec4<uint8_t>{1, 2, 3, 4});
136+
TestBufferFill(uint8_t{1});
137+
TestBufferFill(vec2<uint8_t>{1, 2});
138+
TestBufferFill(vec4<uint8_t>{1, 2, 3, 4});
139139

140-
TestBufferFill(uint16_t{1});
141-
TestBufferFill(vec2<uint16_t>{1, 2});
142-
TestBufferFill(vec4<uint16_t>{1, 2, 3, 4});
140+
TestBufferFill(uint16_t{1});
141+
TestBufferFill(vec2<uint16_t>{1, 2});
142+
TestBufferFill(vec4<uint16_t>{1, 2, 3, 4});
143143

144-
TestBufferFill(uint32_t{1});
145-
TestBufferFill(vec2<uint32_t>{1, 2});
146-
TestBufferFill(vec4<uint32_t>{1, 2, 3, 4});
144+
TestBufferFill(uint32_t{1});
145+
TestBufferFill(vec2<uint32_t>{1, 2});
146+
TestBufferFill(vec4<uint32_t>{1, 2, 3, 4});
147147
}
148148
} // namespace

0 commit comments

Comments
 (0)