[SYCL][UR] Bump UR and implement adapter handles (#10349)

Bump the Unified Runtime commit, and make adapter changes needed for the
newly added adapter handles (see
#715 for details)

This fixes #10066 by providing an implementation of
`piPluginGetLastError` in pi2ur.

Author: callumfare

adapter.cpp

@@ -0,0 +1,89 @@
+//===--------- adapter.cpp - CUDA Adapter ----------------------------===//
+//
+// 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
+//
+//===-----------------------------------------------------------------===//
+
+#include <ur_api.h>
+
+#include "common.hpp"
+
+void enableCUDATracing();
+void disableCUDATracing();
+
+struct ur_adapter_handle_t_ {
+  std::atomic<uint32_t> RefCount = 0;
+  std::mutex Mutex;
+};
+
+ur_adapter_handle_t_ adapter{};
+
+UR_APIEXPORT ur_result_t UR_APICALL urInit(ur_device_init_flags_t,
+                                           ur_loader_config_handle_t) {
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urTearDown(void *) {
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL
+urAdapterGet(uint32_t NumEntries, ur_adapter_handle_t *phAdapters,
+             uint32_t *pNumAdapters) {
+  if (NumEntries > 0 && phAdapters) {
+    std::lock_guard<std::mutex> Lock{adapter.Mutex};
+    if (adapter.RefCount++ == 0) {
+      enableCUDATracing();
+    }
+
+    *phAdapters = &adapter;
+  }
+
+  if (pNumAdapters) {
+    *pNumAdapters = 1;
+  }
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urAdapterRetain(ur_adapter_handle_t) {
+  adapter.RefCount++;
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {
+  std::lock_guard<std::mutex> Lock{adapter.Mutex};
+  if (--adapter.RefCount == 0) {
+    disableCUDATracing();
+  }
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urAdapterGetLastError(
+    ur_adapter_handle_t, const char **ppMessage, int32_t *pError) {
+  *ppMessage = ErrorMessage;
+  *pError = ErrorMessageCode;
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urAdapterGetInfo(ur_adapter_handle_t,
+                                                     ur_adapter_info_t propName,
+                                                     size_t propSize,
+                                                     void *pPropValue,
+                                                     size_t *pPropSizeRet) {
+  UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);
+
+  switch (propName) {
+  case UR_ADAPTER_INFO_BACKEND:
+    return ReturnValue(UR_ADAPTER_BACKEND_CUDA);
+  case UR_ADAPTER_INFO_REFERENCE_COUNT:
+    return ReturnValue(adapter.RefCount.load());
+  default:
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  }
+
+  return UR_RESULT_SUCCESS;
+}

adapter.hpp

@@ -0,0 +1,11 @@
+//===--------- adapter.cpp - CUDA Adapter ----------------------------===//
+//
+// 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
+//
+//===-----------------------------------------------------------------===//
+
+struct ur_adapter_handle_t_;
+
+extern ur_adapter_handle_t_ adapter;

common.cpp

@@ -134,10 +134,3 @@ void setPluginSpecificMessage(CUresult cu_res) {
   setErrorMessage(message, UR_RESULT_ERROR_ADAPTER_SPECIFIC);
   free(message);
 }
-
-// Returns plugin specific error and warning messages; common implementation
-// that can be shared between adapters
-ur_result_t urGetLastResult(ur_platform_handle_t, const char **ppMessage) {
-  *ppMessage = &ErrorMessage[0];
-  return ErrorMessageCode;
-}

device.cpp

@@ -9,6 +9,7 @@
 #include <cassert>
 #include <sstream>
 
+#include "adapter.hpp"
 #include "context.hpp"
 #include "device.hpp"
 #include "platform.hpp"
@@ -1206,13 +1207,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
 
   // Get list of platforms
   uint32_t NumPlatforms = 0;
-  ur_result_t Result = urPlatformGet(0, nullptr, &NumPlatforms);
+  ur_adapter_handle_t AdapterHandle = &adapter;
+  ur_result_t Result =
+      urPlatformGet(&AdapterHandle, 1, 0, nullptr, &NumPlatforms);
   if (Result != UR_RESULT_SUCCESS)
     return Result;
 
   ur_platform_handle_t *Plat = static_cast<ur_platform_handle_t *>(
       malloc(NumPlatforms * sizeof(ur_platform_handle_t)));
-  Result = urPlatformGet(NumPlatforms, Plat, nullptr);
+  Result = urPlatformGet(&AdapterHandle, 1, NumPlatforms, Plat, nullptr);
   if (Result != UR_RESULT_SUCCESS)
     return Result;
 

platform.cpp

@@ -15,9 +15,6 @@
 #include <cuda.h>
 #include <sstream>
 
-void enableCUDATracing();
-void disableCUDATracing();
-
 UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
     ur_platform_handle_t hPlatform, ur_platform_info_t PlatformInfoType,
     size_t Size, void *pPlatformInfo, size_t *pSizeRet) {
@@ -57,8 +54,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
 /// However because multiple devices in a context is not currently supported,
 /// place each device in a separate platform.
 UR_APIEXPORT ur_result_t UR_APICALL
-urPlatformGet(uint32_t NumEntries, ur_platform_handle_t *phPlatforms,
-              uint32_t *pNumPlatforms) {
+urPlatformGet(ur_adapter_handle_t *, uint32_t, uint32_t NumEntries,
+              ur_platform_handle_t *phPlatforms, uint32_t *pNumPlatforms) {
 
   try {
     static std::once_flag InitFlag;
@@ -188,16 +185,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-UR_APIEXPORT ur_result_t UR_APICALL urInit(ur_device_init_flags_t) {
-  enableCUDATracing();
-  return UR_RESULT_SUCCESS;
-}
-
-UR_APIEXPORT ur_result_t UR_APICALL urTearDown(void *) {
-  disableCUDATracing();
-  return UR_RESULT_SUCCESS;
-}
-
 // Get CUDA plugin specific backend option.
 // Current support is only for optimization options.
 // Return empty string for cuda.

ur_interface_loader.cpp

@@ -202,6 +202,12 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetGlobalProcAddrTable(
   }
   pDdiTable->pfnInit = urInit;
   pDdiTable->pfnTearDown = urTearDown;
+  pDdiTable->pfnAdapterGet = urAdapterGet;
+  pDdiTable->pfnAdapterRelease = urAdapterRelease;
+  pDdiTable->pfnAdapterRetain = urAdapterRetain;
+  pDdiTable->pfnAdapterGetLastError = urAdapterGetLastError;
+  pDdiTable->pfnAdapterGetInfo = urAdapterGetInfo;
+
   return UR_RESULT_SUCCESS;
 }
 

usm.cpp

@@ -8,6 +8,7 @@
 
 #include <cassert>
 
+#include "adapter.hpp"
 #include "common.hpp"
 #include "context.hpp"
 #include "device.hpp"
@@ -204,7 +205,9 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
       // the same index
       std::vector<ur_platform_handle_t> Platforms;
       Platforms.resize(DeviceIndex + 1);
-      Result = urPlatformGet(DeviceIndex + 1, Platforms.data(), nullptr);
+      ur_adapter_handle_t AdapterHandle = &adapter;
+      Result = urPlatformGet(&AdapterHandle, 1, DeviceIndex + 1,
+                             Platforms.data(), nullptr);
 
       // get the device from the platform
       ur_device_handle_t Device = Platforms[DeviceIndex]->Devices[0].get();