Remove deprecated hip APIs.

Mostly these APIs were completely redundant already. HIP amd doesn't have have a context concept.

Signed-off-by: JackAKirk <[email protected]>

Author: JackAKirk

source/adapters/hip/command_buffer.cpp

@@ -882,7 +882,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferEnqueueExp(
 
   try {
     std::unique_ptr<ur_event_handle_t_> RetImplEvent{nullptr};
-    ScopedContext Active(hQueue->getDevice());
+    ScopedDevice Active(hQueue->getDevice());
     uint32_t StreamToken;
     ur_stream_guard Guard;
     hipStream_t HIPStream = hQueue->getNextComputeStream(

source/adapters/hip/context.cpp

@@ -32,10 +32,7 @@ ur_context_handle_t_::getOwningURPool(umf_memory_pool_t *UMFPool) {
   return nullptr;
 }
 
-/// Create a UR HIP context.
-///
-/// By default creates a scoped context and keeps the last active HIP context
-/// on top of the HIP context stack.
+/// Create a UR context.
 ///
 UR_APIEXPORT ur_result_t UR_APICALL urContextCreate(
     uint32_t DeviceCount, const ur_device_handle_t *phDevices,
@@ -44,7 +41,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextCreate(
 
   std::unique_ptr<ur_context_handle_t_> ContextPtr{nullptr};
   try {
-    // Create a scoped context.
+    // Create a context.
     ContextPtr = std::unique_ptr<ur_context_handle_t_>(
         new ur_context_handle_t_{phDevices, DeviceCount});
     *phContext = ContextPtr.release();
@@ -115,8 +112,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextGetNativeHandle(
     ur_context_handle_t hContext, ur_native_handle_t *phNativeContext) {
   // FIXME: this entry point has been deprecated in the SYCL RT and should be
   // changed to unsupported once the deprecation period has elapsed
-  *phNativeContext = reinterpret_cast<ur_native_handle_t>(
-      hContext->getDevices()[0]->getNativeContext());
+  // The below is extremely dodgy but is the equivalent for what went before
+  // for continuity: apparently some users may be somehow using this API
+  // currently, despite it not being well defined. This API should not have been
+  // implemented in the HIP backend.  hipCtx_t is not natively supported by amd
+  // devices and is meaningless for our purposes; all hipCtx_t APIs were added
+  // for cuda compatibility only and are deprecated by HIP.
+
+  hipCtx_t *Ctx;
+  UR_CHECK_ERROR(hipCtxGetCurrent(Ctx));
+  *phNativeContext = reinterpret_cast<ur_native_handle_t>(Ctx);
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/hip/context.hpp

@@ -19,35 +19,6 @@
 
 typedef void (*ur_context_extended_deleter_t)(void *UserData);
 
-/// UR context mapping to a HIP context object.
-///
-/// There is no direct mapping between a HIP context and a UR context.
-/// The main differences are described below:
-///
-/// <b> HIP context vs UR context </b>
-///
-/// One of the main differences between the UR API and the HIP driver API is
-/// that the second modifies the state of the threads by assigning
-/// \c hipCtx_t objects to threads. \c hipCtx_t objects store data associated
-/// with a given device and control access to said device from the user side.
-/// UR API context are objects that are passed to functions, and not bound
-/// to threads.
-///
-/// Since the \c ur_context_handle_t can contain multiple devices, and a \c
-/// hipCtx_t refers to only a single device, the \c hipCtx_t is more tightly
-/// coupled to a \c ur_device_handle_t than a \c ur_context_handle_t. In order
-/// to remove some ambiguities about the different semantics of \c
-/// \c ur_context_handle_t and native \c hipCtx_t, we access the native \c
-/// hipCtx_t solely through the \c ur_device_handle_t class, by using the object
-/// \ref ScopedContext, which sets the active device (by setting the active
-/// native \c hipCtx_t).
-///
-/// <b> Primary vs User-defined \c hipCtx_t </b>
-///
-/// HIP has two different types of \c hipCtx_t, the Primary context, which is
-/// usable by all threads on a given process for a given device, and the
-/// aforementioned custom \c hipCtx_t s. The HIP documentation, confirmed with
-/// performance analysis, suggest using the Primary context whenever possible.
 ///
 ///  <b> Destructor callback </b>
 ///
@@ -76,24 +47,14 @@ struct ur_context_handle_t_ {
     void operator()() { Function(UserData); }
   };
 
-  using native_type = hipCtx_t;
-
   std::vector<ur_device_handle_t> Devices;
 
   std::atomic_uint32_t RefCount;
 
   ur_context_handle_t_(const ur_device_handle_t *Devs, uint32_t NumDevices)
-      : Devices{Devs, Devs + NumDevices}, RefCount{1} {
-    for (auto &Dev : Devices) {
-      urDeviceRetain(Dev);
-    }
-  };
+      : Devices{Devs, Devs + NumDevices}, RefCount{1} {};
 
-  ~ur_context_handle_t_() {
-    for (auto &Dev : Devices) {
-      urDeviceRelease(Dev);
-    }
-  }
+  ~ur_context_handle_t_() {}
 
   void invokeExtendedDeleters() {
     std::lock_guard<std::mutex> Guard(Mutex);
@@ -136,28 +97,3 @@ struct ur_context_handle_t_ {
   std::vector<deleter_data> ExtendedDeleters;
   std::set<ur_usm_pool_handle_t> PoolHandles;
 };
-
-namespace {
-/// Scoped context is used across all UR HIP plugin implementation to activate
-/// the native Context on the current thread. The ScopedContext does not
-/// reinstate the previous context as all operations in the hip adapter that
-/// require an active context, set the active context and don't rely on context
-/// reinstation
-class ScopedContext {
-public:
-  ScopedContext(ur_device_handle_t hDevice) {
-    hipCtx_t Original{};
-
-    if (!hDevice) {
-      throw UR_RESULT_ERROR_INVALID_DEVICE;
-    }
-
-    hipCtx_t Desired = hDevice->getNativeContext();
-    UR_CHECK_ERROR(hipCtxGetCurrent(&Original));
-    if (Original != Desired) {
-      // Sets the desired context as the active one for the thread
-      UR_CHECK_ERROR(hipCtxSetCurrent(Desired));
-    }
-  }
-};
-} // namespace

source/adapters/hip/device.cpp

@@ -1077,7 +1077,7 @@ ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(ur_device_handle_t hDevice,
     return UR_RESULT_SUCCESS;
 
   ur_event_handle_t_::native_type Event;
-  ScopedContext Active(hDevice);
+  ScopedDevice Active(hDevice);
 
   if (pDeviceTimestamp) {
     UR_CHECK_ERROR(hipEventCreateWithFlags(&Event, hipEventDefault));

source/adapters/hip/device.hpp

@@ -24,7 +24,6 @@ struct ur_device_handle_t_ {
   native_type HIPDevice;
   std::atomic_uint32_t RefCount;
   ur_platform_handle_t Platform;
-  hipCtx_t HIPContext;
   hipEvent_t EvBase; // HIP event used as base counter
   uint32_t DeviceIndex;
 
@@ -37,11 +36,10 @@ struct ur_device_handle_t_ {
   int ConcurrentManagedAccess{0};
 
 public:
-  ur_device_handle_t_(native_type HipDevice, hipCtx_t Context,
-                      hipEvent_t EvBase, ur_platform_handle_t Platform,
-                      uint32_t DeviceIndex)
-      : HIPDevice(HipDevice), RefCount{1}, Platform(Platform),
-        HIPContext(Context), EvBase(EvBase), DeviceIndex(DeviceIndex) {
+  ur_device_handle_t_(native_type HipDevice, hipEvent_t EvBase,
+                      ur_platform_handle_t Platform, uint32_t DeviceIndex)
+      : HIPDevice(HipDevice), RefCount{1}, Platform(Platform), EvBase(EvBase),
+        DeviceIndex(DeviceIndex) {
 
     UR_CHECK_ERROR(hipDeviceGetAttribute(
         &MaxWorkGroupSize, hipDeviceAttributeMaxThreadsPerBlock, HIPDevice));
@@ -61,9 +59,7 @@ struct ur_device_handle_t_ {
         HIPDevice));
   }
 
-  ~ur_device_handle_t_() noexcept(false) {
-    UR_CHECK_ERROR(hipDevicePrimaryCtxRelease(HIPDevice));
-  }
+  ~ur_device_handle_t_() noexcept(false) {}
 
   native_type get() const noexcept { return HIPDevice; };
 
@@ -73,8 +69,6 @@ struct ur_device_handle_t_ {
 
   uint64_t getElapsedTime(hipEvent_t) const;
 
-  hipCtx_t getNativeContext() const noexcept { return HIPContext; };
-
   // Returns the index of the device relative to the other devices in the same
   // platform
   uint32_t getIndex() const noexcept { return DeviceIndex; };
@@ -97,3 +91,20 @@ struct ur_device_handle_t_ {
 };
 
 int getAttribute(ur_device_handle_t Device, hipDeviceAttribute_t Attribute);
+
+namespace {
+/// Scoped Device is used across all UR HIP plugin implementation to activate
+/// the native Device on the current thread. The ScopedDevice does not
+/// reinstate the previous device as all operations in the hip adapter that
+/// require an active device, set the active device and don't rely on device
+/// reinstation
+class ScopedDevice {
+public:
+  ScopedDevice(ur_device_handle_t hDevice) {
+    if (!hDevice) {
+      throw UR_RESULT_ERROR_INVALID_DEVICE;
+    }
+    hipSetDevice(hDevice->get());
+  }
+};
+} // namespace