[SYCL] Make backend a property of a platform (#9153)

Signed-off-by: Sergey V Maslov <[email protected]>

Author: smaslov-intel

sycl/include/sycl/backend.hpp

@@ -51,6 +51,9 @@ namespace detail {
 // TODO each backend can have its own custom errc enumeration
 // but the details for this are not fully specified yet
 enum class backend_errc : unsigned int {};
+
+// Convert from PI backend to SYCL backend enum
+backend convertBackend(pi_platform_backend PiBackend);
 } // namespace detail
 
 template <backend Backend> class backend_traits {

sycl/include/sycl/detail/pi.h

@@ -210,6 +210,7 @@ typedef enum {
   PI_EXT_PLATFORM_BACKEND_OPENCL = 2,     ///< The backend is OpenCL
   PI_EXT_PLATFORM_BACKEND_CUDA = 3,       ///< The backend is CUDA
   PI_EXT_PLATFORM_BACKEND_HIP = 4,        ///< The backend is HIP
+  PI_EXT_PLATFORM_BACKEND_ESIMD = 5,      ///< The backend is ESIMD
 } _pi_platform_backend;
 
 typedef enum {

sycl/include/sycl/detail/pi.hpp

@@ -117,6 +117,7 @@ void handleUnknownParamName(const char *functionName, T parameter) {
 using PiPlugin = ::pi_plugin;
 using PiResult = ::pi_result;
 using PiPlatform = ::pi_platform;
+using PiPlatformBackend = ::pi_platform_backend;
 using PiDevice = ::pi_device;
 using PiDeviceType = ::pi_device_type;
 using PiDeviceInfo = ::pi_device_info;

sycl/plugins/esimd_emulator/pi_esimd_emulator.cpp

@@ -485,9 +485,9 @@ pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName,
     return ReturnValue("");
 
   case PI_EXT_PLATFORM_INFO_BACKEND:
-    return getInfo<pi_platform_backend>(
-        ParamValueSize, ParamValue, ParamValueSizeRet,
-        PI_EXT_PLATFORM_BACKEND_UNKNOWN); // TODO: add ESIMD to UR?
+    return getInfo<pi_platform_backend>(ParamValueSize, ParamValue,
+                                        ParamValueSizeRet,
+                                        PI_EXT_PLATFORM_BACKEND_ESIMD);
 
   default:
     // TODO: implement other parameters

sycl/source/backend.cpp

@@ -38,7 +38,27 @@ static const plugin &getPlugin(backend Backend) {
   case backend::ext_oneapi_cuda:
     return pi::getPlugin<backend::ext_oneapi_cuda>();
   default:
-    throw sycl::runtime_error{"Unsupported backend",
+    throw sycl::runtime_error{"getPlugin: Unsupported backend",
+                              PI_ERROR_INVALID_OPERATION};
+  }
+}
+
+backend convertBackend(pi_platform_backend PiBackend) {
+  switch (PiBackend) {
+  case PI_EXT_PLATFORM_BACKEND_UNKNOWN:
+    return backend::all; // No specific backend
+  case PI_EXT_PLATFORM_BACKEND_LEVEL_ZERO:
+    return backend::ext_oneapi_level_zero;
+  case PI_EXT_PLATFORM_BACKEND_OPENCL:
+    return backend::opencl;
+  case PI_EXT_PLATFORM_BACKEND_CUDA:
+    return backend::ext_oneapi_cuda;
+  case PI_EXT_PLATFORM_BACKEND_HIP:
+    return backend::ext_oneapi_hip;
+  case PI_EXT_PLATFORM_BACKEND_ESIMD:
+    return backend::ext_intel_esimd_emulator;
+  default:
+    throw sycl::runtime_error{"convertBackend: Unsupported backend",
                               PI_ERROR_INVALID_OPERATION};
   }
 }
@@ -176,7 +196,7 @@ make_kernel_bundle(pi_native_handle NativeHandle, const context &TargetContext,
   pi::PiProgram PiProgram = nullptr;
   Plugin.call<PiApiKind::piextProgramCreateWithNativeHandle>(
       NativeHandle, ContextImpl->getHandleRef(), !KeepOwnership, &PiProgram);
-  if (Plugin.getBackend() == backend::opencl)
+  if (ContextImpl->getBackend() == backend::opencl)
     Plugin.call<PiApiKind::piProgramRetain>(PiProgram);
 
   std::vector<pi::PiDevice> ProgramDevices;

sycl/source/context.cpp

@@ -130,7 +130,7 @@ bool context::is_host() const {
   return IsHost;
 }
 
-backend context::get_backend() const noexcept { return getImplBackend(impl); }
+backend context::get_backend() const noexcept { return impl->getBackend(); }
 
 platform context::get_platform() const {
   return impl->get_info<info::context::platform>();

sycl/source/detail/allowlist.cpp

@@ -5,11 +5,12 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-
 #include <detail/allowlist.hpp>
 #include <detail/config.hpp>
 #include <detail/device_impl.hpp>
+#include <detail/device_info.hpp>
 #include <detail/platform_info.hpp>
+#include <sycl/backend.hpp>
 
 #include <algorithm>
 #include <regex>
@@ -335,15 +336,17 @@ bool deviceIsAllowed(const DeviceDescT &DeviceDesc,
 
 void applyAllowList(std::vector<RT::PiDevice> &PiDevices,
                     RT::PiPlatform PiPlatform, const plugin &Plugin) {
+
   AllowListParsedT AllowListParsed =
       parseAllowList(SYCLConfig<SYCL_DEVICE_ALLOWLIST>::get());
   if (AllowListParsed.empty())
     return;
 
+  // Get platform's backend and put it to DeviceDesc
   DeviceDescT DeviceDesc;
+  auto PlatformImpl = platform_impl::getOrMakePlatformImpl(PiPlatform, Plugin);
+  backend Backend = PlatformImpl->getBackend();
 
-  // get BackendName value and put it to DeviceDesc
-  sycl::backend Backend = Plugin.getBackend();
   for (const auto &SyclBe : getSyclBeMap()) {
     if (SyclBe.second == Backend) {
       DeviceDesc.emplace(BackendNameKeyName, SyclBe.first);
@@ -361,6 +364,7 @@ void applyAllowList(std::vector<RT::PiDevice> &PiDevices,
 
   int InsertIDx = 0;
   for (RT::PiDevice Device : PiDevices) {
+    auto DeviceImpl = PlatformImpl->getOrMakeDeviceImpl(Device, PlatformImpl);
     // get DeviceType value and put it to DeviceDesc
     RT::PiDeviceType PiDevType;
     Plugin.call<PiApiKind::piDeviceGetInfo>(Device, PI_DEVICE_INFO_TYPE,
@@ -376,19 +380,18 @@ void applyAllowList(std::vector<RT::PiDevice> &PiDevices,
     }
     // get DeviceVendorId value and put it to DeviceDesc
     uint32_t DeviceVendorIdUInt =
-        sycl::detail::get_device_info<info::device::vendor_id>(Device, Plugin);
+        sycl::detail::get_device_info<info::device::vendor_id>(DeviceImpl);
     std::stringstream DeviceVendorIdHexStringStream;
     DeviceVendorIdHexStringStream << "0x" << std::hex << DeviceVendorIdUInt;
     const auto &DeviceVendorIdValue = DeviceVendorIdHexStringStream.str();
     DeviceDesc[DeviceVendorIdKeyName] = DeviceVendorIdValue;
     // get DriverVersion value and put it to DeviceDesc
     const std::string &DriverVersionValue =
-        sycl::detail::get_device_info<info::device::driver_version>(Device,
-                                                                    Plugin);
+        sycl::detail::get_device_info<info::device::driver_version>(DeviceImpl);
     DeviceDesc[DriverVersionKeyName] = DriverVersionValue;
     // get DeviceName value and put it to DeviceDesc
     const std::string &DeviceNameValue =
-        sycl::detail::get_device_info<info::device::name>(Device, Plugin);
+        sycl::detail::get_device_info<info::device::name>(DeviceImpl);
     DeviceDesc[DeviceNameKeyName] = DeviceNameValue;
 
     // check if we can allow device with such device description DeviceDesc

sycl/source/detail/backend_impl.hpp

@@ -16,7 +16,7 @@ namespace detail {
 
 template <class T> backend getImplBackend(const T &Impl) {
   assert(!Impl->is_host() && "Cannot get the backend for host.");
-  return Impl->getPlugin().getBackend();
+  return Impl->getContextImplPtr()->getBackend();
 }
 
 } // namespace detail

sycl/source/detail/buffer_impl.cpp

@@ -76,9 +76,9 @@ buffer_impl::getNativeVector(backend BackendName) const {
       continue;
     auto Plugin = Platform->getPlugin();
 
-    if (Plugin.getBackend() != BackendName)
+    if (Platform->getBackend() != BackendName)
       continue;
-    if (Plugin.getBackend() == backend::opencl) {
+    if (Platform->getBackend() == backend::opencl) {
       Plugin.call<PiApiKind::piMemRetain>(NativeMem);
     }
 

sycl/source/detail/context_impl.cpp

@@ -50,8 +50,7 @@ context_impl::context_impl(const std::vector<sycl::device> Devices,
     DeviceIds.push_back(getSyclObjImpl(D)->getHandleRef());
   }
 
-  const auto Backend = getPlugin().getBackend();
-  if (Backend == backend::ext_oneapi_cuda) {
+  if (getBackend() == backend::ext_oneapi_cuda) {
     const bool UseCUDAPrimaryContext = MPropList.has_property<
         ext::oneapi::cuda::property::context::use_primary_context>();
     const pi_context_properties Props[] = {
@@ -102,7 +101,7 @@ context_impl::context_impl(RT::PiContext PiContext, async_handler AsyncHandler,
   //
   // TODO: Move this backend-specific retain of the context to SYCL-2020 style
   //       make_context<backend::opencl> interop, when that is created.
-  if (getPlugin().getBackend() == sycl::backend::opencl) {
+  if (getBackend() == sycl::backend::opencl) {
     getPlugin().call<PiApiKind::piContextRetain>(MContext);
   }
   MKernelProgramCache.setContextPtr(this);
@@ -257,7 +256,7 @@ context_impl::findMatchingDeviceImpl(RT::PiDevice &DevicePI) const {
 
 pi_native_handle context_impl::getNative() const {
   auto Plugin = getPlugin();
-  if (Plugin.getBackend() == backend::opencl)
+  if (getBackend() == backend::opencl)
     Plugin.call<PiApiKind::piContextRetain>(getHandleRef());
   pi_native_handle Handle;
   Plugin.call<PiApiKind::piextContextGetNativeHandle>(getHandleRef(), &Handle);