Change cuda adapter back to using dumb pointers.

Author: aarongreig

unified-runtime/source/adapters/cuda/adapter.cpp

@@ -16,7 +16,7 @@
 #include <memory>
 
 namespace ur::cuda {
-std::shared_ptr<ur_adapter_handle_t_> adapter;
+ur_adapter_handle_t adapter;
 } // namespace ur::cuda
 
 class ur_legacy_sink : public logger::Sink {
@@ -47,22 +47,25 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
        std::getenv("UR_SUPPRESS_ERROR_MESSAGE") != nullptr)) {
     logger.setLegacySink(std::make_unique<ur_legacy_sink>());
   }
+
+  TracingCtx = createCUDATracingContext();
+  enableCUDATracing(TracingCtx);
+}
+
+ur_adapter_handle_t_::~ur_adapter_handle_t_() {
+  disableCUDATracing(TracingCtx);
+  freeCUDATracingContext(TracingCtx);
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL
 urAdapterGet(uint32_t NumEntries, ur_adapter_handle_t *phAdapters,
              uint32_t *pNumAdapters) {
   if (NumEntries > 0 && phAdapters) {
     static std::once_flag InitFlag;
-    std::call_once(InitFlag, [=]() {
-      ur::cuda::adapter = std::make_shared<ur_adapter_handle_t_>();
-    });
-
-    std::lock_guard<std::mutex> Lock{ur::cuda::adapter->Mutex};
-    ur::cuda::adapter->TracingCtx = createCUDATracingContext();
-    enableCUDATracing(ur::cuda::adapter->TracingCtx);
+    std::call_once(InitFlag,
+                   [=]() { ur::cuda::adapter = new ur_adapter_handle_t_; });
 
-    *phAdapters = ur::cuda::adapter.get();
+    *phAdapters = ur::cuda::adapter;
   }
 
   if (pNumAdapters) {
@@ -79,11 +82,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterRetain(ur_adapter_handle_t) {
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {
-  std::lock_guard<std::mutex> Lock{ur::cuda::adapter->Mutex};
   if (--ur::cuda::adapter->RefCount == 0) {
-    disableCUDATracing(ur::cuda::adapter->TracingCtx);
-    freeCUDATracingContext(ur::cuda::adapter->TracingCtx);
-    ur::cuda::adapter.reset();
+    delete ur::cuda::adapter;
   }
   return UR_RESULT_SUCCESS;
 }

unified-runtime/source/adapters/cuda/adapter.hpp

@@ -18,20 +18,20 @@
 
 #include <atomic>
 #include <memory>
-#include <mutex>
 
 struct ur_adapter_handle_t_ {
   std::atomic<uint32_t> RefCount = 1;
-  std::mutex Mutex;
   struct cuda_tracing_context_t_ *TracingCtx = nullptr;
   logger::Logger &logger;
   std::unique_ptr<ur_platform_handle_t_> Platform;
   ur_adapter_handle_t_();
+  ~ur_adapter_handle_t_();
+  ur_adapter_handle_t_(const ur_adapter_handle_t_ &) = delete;
 };
 
 // Keep the global namespace'd
 namespace ur::cuda {
-extern std::shared_ptr<ur_adapter_handle_t_> adapter;
+extern ur_adapter_handle_t adapter;
 } // namespace ur::cuda
 
 #endif // UR_CUDA_ADAPTER_HPP_INCLUDED

unified-runtime/source/adapters/cuda/context.hpp

@@ -119,10 +119,6 @@ struct ur_context_handle_t_ {
     void operator()() { Function(UserData); }
   };
 
-  // Retain an additional reference to the adapter as it keeps the devices
-  // alive, which end up being used (indirectly) by our destructor.
-  std::shared_ptr<ur_adapter_handle_t_> Adapter;
-
   std::vector<ur_device_handle_t> Devices;
   std::atomic_uint32_t RefCount;
 
@@ -132,13 +128,13 @@ struct ur_context_handle_t_ {
   umf_memory_pool_handle_t MemoryPoolHost = nullptr;
 
   ur_context_handle_t_(const ur_device_handle_t *Devs, uint32_t NumDevices)
-      : Adapter(ur::cuda::adapter), Devices{Devs, Devs + NumDevices},
-        RefCount{1} {
+      : Devices{Devs, Devs + NumDevices}, RefCount{1} {
     // Create UMF CUDA memory provider for the host memory
     // (UMF_MEMORY_TYPE_HOST) from any device (Devices[0] is used here, because
     // it is guaranteed to exist).
     UR_CHECK_ERROR(CreateHostMemoryProviderPool(Devices[0], &MemoryProviderHost,
                                                 &MemoryPoolHost));
+    UR_CHECK_ERROR(urAdapterRetain(ur::cuda::adapter));
   };
 
   ~ur_context_handle_t_() {
@@ -148,6 +144,7 @@ struct ur_context_handle_t_ {
     if (MemoryProviderHost) {
       umfMemoryProviderDestroy(MemoryProviderHost);
     }
+    UR_CHECK_ERROR(urAdapterRelease(ur::cuda::adapter));
   }
 
   void invokeExtendedDeleters() {

unified-runtime/source/adapters/cuda/device.cpp

@@ -1282,7 +1282,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
 
   // Get list of platforms
   uint32_t NumPlatforms = 0;
-  ur_adapter_handle_t AdapterHandle = ur::cuda::adapter.get();
+  ur_adapter_handle_t AdapterHandle = ur::cuda::adapter;
   ur_result_t Result =
       urPlatformGet(&AdapterHandle, 1, 0, nullptr, &NumPlatforms);
   if (Result != UR_RESULT_SUCCESS)

unified-runtime/source/adapters/cuda/platform.cpp

@@ -100,7 +100,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
     return ReturnValue(UR_PLATFORM_BACKEND_CUDA);
   }
   case UR_PLATFORM_INFO_ADAPTER: {
-    return ReturnValue(ur::cuda::adapter.get());
+    return ReturnValue(ur::cuda::adapter);
   }
   default:
     return UR_RESULT_ERROR_INVALID_ENUMERATION;

unified-runtime/source/adapters/cuda/usm.cpp

@@ -242,7 +242,7 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
 
       // cuda backend has only one platform containing all devices
       ur_platform_handle_t platform;
-      ur_adapter_handle_t AdapterHandle = ur::cuda::adapter.get();
+      ur_adapter_handle_t AdapterHandle = ur::cuda::adapter;
       Result = urPlatformGet(&AdapterHandle, 1, 1, &platform, nullptr);
 
       // get the device from the platform