Backend agnostic PI tests are parameterised by PI Plugin.

Enable CUDA + OpenCL PI unit tests.

Signed-off-by: Stuart Adams <[email protected]>

Author: nyalloc

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

@@ -132,6 +132,8 @@ typedef enum {
 // make the translation to OpenCL transparent.
 //
 typedef enum : pi_uint64 {
+  PI_DEVICE_TYPE_DEFAULT = CL_DEVICE_TYPE_DEFAULT,
+  PI_DEVICE_TYPE_ALL = CL_DEVICE_TYPE_ALL,
   PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU,
   PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU,
   PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR

sycl/plugins/cuda/pi_cuda.cpp

@@ -716,15 +716,18 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type,
                             pi_uint32 *num_devices) {
 
   pi_result err = PI_SUCCESS;
-  const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU);
-  size_t numDevices = askingForGPU ? platform->devices_.size() : 0;
+  const bool askingForDefault = device_type == PI_DEVICE_TYPE_DEFAULT;
+  const bool askingForGPU = device_type & PI_DEVICE_TYPE_GPU;
+  const bool returnDevices = askingForDefault || askingForGPU;
+
+  size_t numDevices = returnDevices ? platform->devices_.size() : 0;
 
   try {
     if (num_devices) {
       *num_devices = numDevices;
     }
 
-    if (askingForGPU && devices) {
+    if (returnDevices && devices) {
       for (size_t i = 0; i < std::min(size_t(num_entries), numDevices); ++i) {
         devices[i] = platform->devices_[i].get();
       }

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

sycl/unittests/pi/EnqueueMemTest.cpp

@@ -13,10 +13,8 @@
 using namespace cl::sycl;
 
 namespace {
-class DISABLED_EnqueueMemTest : public ::testing::Test {
+class EnqueueMemTest : public testing::TestWithParam<detail::plugin> {
 protected:
-  std::vector<detail::plugin> Plugins;
-
   constexpr static size_t _numElementsX = 8;
   constexpr static size_t _numElementsY = 4;
 
@@ -25,72 +23,77 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
   pi_queue _queue = nullptr;
   pi_mem _mem = nullptr;
 
-  DISABLED_EnqueueMemTest() = default;
+  EnqueueMemTest() = default;
 
-  ~DISABLED_EnqueueMemTest() = default;
+  ~EnqueueMemTest() = default;
 
   void SetUp() override {
-    Plugins = detail::pi::initialize();
-    ASSERT_FALSE(Plugins.empty());
+
+    detail::plugin plugin = GetParam();
 
     pi_platform platform = nullptr;
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   1, &platform, nullptr)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
-                  platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+                  platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)),
               PI_SUCCESS);
 
     pi_result result = PI_INVALID_VALUE;
-    result = Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
+    result = plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
         nullptr, 1u, &_device, nullptr, nullptr, &_context);
     ASSERT_EQ(result, PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   _context, _device, 0, &_queue)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                   _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
                   nullptr, &_mem)),
               PI_SUCCESS);
   }
 
   void TearDown() override {
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
+
+    detail::plugin plugin = GetParam();
+
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
               PI_SUCCESS);
     ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
+        (plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
         PI_SUCCESS);
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(
                   _context)),
               PI_SUCCESS);
   }
 
   template <typename T> 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(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+        (plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
             _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0,
             nullptr, nullptr)),
         PI_SUCCESS);
 
     ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
+        (plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
             _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr,
             nullptr)),
         PI_SUCCESS);
 
     T outValues[_numElementsX] = {};
     ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+        (plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
             _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0,
             nullptr, nullptr)),
         PI_SUCCESS);
@@ -101,6 +104,12 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
   }
 };
 
+static std::vector<detail::plugin> Plugins = detail::pi::initialize();
+
+INSTANTIATE_TEST_CASE_P(EnqueueMemTestImpl,
+                        EnqueueMemTest,
+                        testing::ValuesIn(Plugins),); 
+
 template<typename T>
 struct vec4 {
   T x, y, z, w;
@@ -127,7 +136,7 @@ struct vec2 {
   }
 };
 
-TEST_F(DISABLED_EnqueueMemTest, piEnqueueMemBufferFill) {
+TEST_P(EnqueueMemTest, piEnqueueMemBufferFill) {
 
     TestBufferFill(float{1});
     TestBufferFill(vec2<float>{1, 2});