[SYCL][CUDA] Fixes CUDA unit tests that uses SYCL directly (#1763)

CUDA-specific unit tests that use SYCL directly fail if another backend
is in use. This commit fixes this by actively selecting CUDA platforms
and only runs the tests on these.

Signed-off-by: Steffen Larsen <[email protected]>

Author: steffenlarsen

sycl/unittests/pi/TestGetPlatforms.hpp

@@ -0,0 +1,30 @@
+// 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 <CL/sycl.hpp>
+#include <algorithm>
+#include <functional>
+#include <vector>
+
+namespace pi {
+inline std::vector<cl::sycl::platform> getPlatformsWithName(const char *name) {
+  std::vector<cl::sycl::platform> platforms =
+      cl::sycl::platform::get_platforms();
+
+  // Remove platforms that have no devices or doesn't contain the name
+  auto end =
+      std::remove_if(platforms.begin(), platforms.end(),
+                     [=](const cl::sycl::platform &platform) -> bool {
+                       const std::string platformName =
+                           platform.get_info<cl::sycl::info::platform::name>();
+                       return platformName.find(name) == std::string::npos ||
+                              platform.get_devices().size() == 0;
+                     });
+  platforms.erase(end, platforms.end());
+
+  return platforms;
+}
+} // namespace pi

sycl/unittests/pi/cuda/test_interop_get_native.cpp

@@ -8,61 +8,44 @@
 
 #include "gtest/gtest.h"
 
+#include "TestGetPlatforms.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/backend/cuda.hpp>
 #include <cuda.h>
 #include <iostream>
 
 using namespace cl::sycl;
 
-struct CudaInteropGetNativeTests : public ::testing::Test {
+struct CudaInteropGetNativeTests : public ::testing::TestWithParam<platform> {
 
 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<info::device::platform>();
-    const std::string platformVersion =
-        platform.get_info<info::platform::version>();
-    const std::string platformName = platform.get_info<info::platform::name>();
-    // 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;
+  void SetUp() override {
+    syclDevice_ = GetParam().get_devices()[0];
+    syclQueue_ = queue{syclDevice_};
+    syclContext_ = syclQueue_.get_context();
   }
 
-  class cuda_device_selector : public device_selector {
-  public:
-    int operator()(const device &dev) const {
-      return isCudaDevice(dev) ? 1000 : -1000;
-    }
-  };
-
-  void SetUp() override {}
-
   void TearDown() override {}
 };
 
-TEST_F(CudaInteropGetNativeTests, getNativeDevice) {
+TEST_P(CudaInteropGetNativeTests, getNativeDevice) {
   CUdevice cudaDevice = get_native<backend::cuda>(syclDevice_);
   char cudaDeviceName[2] = {0, 0};
   CUresult result = cuDeviceGetName(cudaDeviceName, 2, cudaDevice);
   ASSERT_EQ(result, CUDA_SUCCESS);
   ASSERT_NE(cudaDeviceName[0], 0);
 }
 
-TEST_F(CudaInteropGetNativeTests, getNativeContext) {
+TEST_P(CudaInteropGetNativeTests, getNativeContext) {
   CUcontext cudaContext = get_native<backend::cuda>(syclContext_);
   ASSERT_NE(cudaContext, nullptr);
 }
 
-TEST_F(CudaInteropGetNativeTests, getNativeQueue) {
+TEST_P(CudaInteropGetNativeTests, getNativeQueue) {
   CUstream cudaStream = get_native<backend::cuda>(syclQueue_);
   ASSERT_NE(cudaStream, nullptr);
 
@@ -74,21 +57,25 @@ TEST_F(CudaInteropGetNativeTests, getNativeQueue) {
   ASSERT_EQ(streamContext, cudaContext);
 }
 
-TEST_F(CudaInteropGetNativeTests, interopTaskGetMem) {
+TEST_P(CudaInteropGetNativeTests, interopTaskGetMem) {
   buffer<int, 1> syclBuffer(range<1>{1});
   syclQueue_.submit([&](handler &cgh) {
     auto syclAccessor = syclBuffer.get_access<access::mode::read>(cgh);
     cgh.interop_task([=](interop_handler ih) {
       CUdeviceptr cudaPtr = ih.get_mem<backend::cuda>(syclAccessor);
       CUdeviceptr cudaPtrBase;
       size_t cudaPtrSize = 0;
-      cuMemGetAddressRange(&cudaPtrBase, &cudaPtrSize, cudaPtr);
-      ASSERT_EQ(cudaPtrSize, sizeof(int));
+      CUcontext cudaContext = get_native<backend::cuda>(syclContext_);
+      ASSERT_EQ(CUDA_SUCCESS, cuCtxPushCurrent(cudaContext));
+      ASSERT_EQ(CUDA_SUCCESS,
+                cuMemGetAddressRange(&cudaPtrBase, &cudaPtrSize, cudaPtr));
+      ASSERT_EQ(CUDA_SUCCESS, cuCtxPopCurrent(nullptr));
+      ASSERT_EQ(sizeof(int), cudaPtrSize);
     });
   });
 }
 
-TEST_F(CudaInteropGetNativeTests, interopTaskGetBufferMem) {
+TEST_P(CudaInteropGetNativeTests, interopTaskGetBufferMem) {
   CUstream cudaStream = get_native<backend::cuda>(syclQueue_);
   syclQueue_.submit([&](handler &cgh) {
     cgh.interop_task([=](interop_handler ih) {
@@ -97,3 +84,7 @@ TEST_F(CudaInteropGetNativeTests, interopTaskGetBufferMem) {
     });
   });
 }
+
+INSTANTIATE_TEST_CASE_P(
+    OnCudaPlatform, CudaInteropGetNativeTests,
+    ::testing::ValuesIn(pi::getPlatformsWithName("CUDA BACKEND")), );

sycl/unittests/pi/cuda/test_primary_context.cpp

@@ -10,75 +10,32 @@
 
 #include <cuda.h>
 
-#include "TestGetPlugin.hpp"
+#include "TestGetPlatforms.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/backend/cuda.hpp>
-#include <detail/plugin.hpp>
 #include <pi_cuda.hpp>
 
 #include <iostream>
 
 using namespace cl::sycl;
 
-struct CudaPrimaryContextTests : public ::testing::Test {
+struct CudaPrimaryContextTests : public ::testing::TestWithParam<platform> {
 
 protected:
   device deviceA_;
   device deviceB_;
-  context context_;
-
-  static bool isCudaDevice(const device &dev) {
-    const platform platform = dev.get_info<info::device::platform>();
-    const std::string platformVersion =
-        platform.get_info<info::platform::version>();
-    // If using PI_CUDA, don't accept a non-CUDA device
-    return platformVersion.find("CUDA BACKEND") != std::string::npos;
-  }
-
-  class cuda_device_selector : public device_selector {
-  public:
-    int operator()(const device &dev) const {
-      return isCudaDevice(dev) ? 1 : -1;
-    }
-  };
-
-  class other_cuda_device_selector : public device_selector {
-  public:
-    other_cuda_device_selector(const device &dev) : excludeDevice{dev} {}
-
-    int operator()(const device &dev) const {
-      if (!isCudaDevice(dev)) {
-        return -1;
-      }
-      if (dev.get() == excludeDevice.get()) {
-        // Return only this device if it is the only available
-        return 0;
-      }
-      return 1;
-    }
-
-  private:
-    const device &excludeDevice;
-  };
 
   void SetUp() override {
+    std::vector<device> CudaDevices = GetParam().get_devices();
 
-    try {
-      context context_;
-    } catch (device_error &e) {
-      std::cout << "Failed to create device for context" << std::endl;
-    }
-
-    deviceA_ = cuda_device_selector().select_device();
-    deviceB_ = other_cuda_device_selector(deviceA_).select_device();
-
-    ASSERT_TRUE(isCudaDevice(deviceA_));
+    deviceA_ = CudaDevices[0];
+    deviceB_ = CudaDevices.size() > 1 ? CudaDevices[1] : deviceA_;
   }
 
   void TearDown() override {}
 };
 
-TEST_F(CudaPrimaryContextTests, piSingleContext) {
+TEST_P(CudaPrimaryContextTests, piSingleContext) {
   std::cout << "create single context" << std::endl;
   context Context(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
 
@@ -93,7 +50,7 @@ TEST_F(CudaPrimaryContextTests, piSingleContext) {
   cuDevicePrimaryCtxRelease(CudaDevice);
 }
 
-TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) {
+TEST_P(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,18 +61,25 @@ TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) {
   ASSERT_EQ(CudaContextA, CudaContextB);
 }
 
-TEST_F(CudaPrimaryContextTests, piMultiContextMultiDevice) {
+TEST_P(CudaPrimaryContextTests, piMultiContextMultiDevice) {
+  if (deviceA_ == deviceB_)
+    return;
+
   CUdevice CudaDeviceA = deviceA_.get_native<backend::cuda>();
   CUdevice CudaDeviceB = deviceB_.get_native<backend::cuda>();
 
-  if (isCudaDevice(deviceB_) && CudaDeviceA != CudaDeviceB) {
-    std::cout << "create multiple contexts for multiple devices" << std::endl;
-    context ContextA(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
-    context ContextB(deviceB_, async_handler{}, /*UsePrimaryContext=*/true);
+  ASSERT_NE(CudaDeviceA, CudaDeviceB);
 
-    CUcontext CudaContextA = ContextA.get_native<backend::cuda>();
-    CUcontext CudaContextB = ContextB.get_native<backend::cuda>();
+  std::cout << "create multiple contexts for multiple devices" << std::endl;
+  context ContextA(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
+  context ContextB(deviceB_, async_handler{}, /*UsePrimaryContext=*/true);
 
-    ASSERT_NE(CudaContextA, CudaContextB);
-  }
+  CUcontext CudaContextA = ContextA.get_native<backend::cuda>();
+  CUcontext CudaContextB = ContextB.get_native<backend::cuda>();
+
+  ASSERT_NE(CudaContextA, CudaContextB);
 }
+
+INSTANTIATE_TEST_CASE_P(
+    OnCudaPlatform, CudaPrimaryContextTests,
+    ::testing::ValuesIn(pi::getPlatformsWithName("CUDA BACKEND")), );