[SYCL][UR][L0] Clean up PI references in Level Zero adapter (#10572)

Signed-off-by: Jaime Arteaga <[email protected]>

Author: Jaime Arteaga

sycl/plugins/unified_runtime/pi2ur.hpp

@@ -500,7 +500,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp(
   LaunchEvent->CommandData = (void *)Kernel;
   // Increment the reference count of the Kernel and indicate that the Kernel
   // is in use. Once the event has been signalled, the code in
-  // CleanupCompletedEvent(Event) will do a piReleaseKernel to update the
+  // CleanupCompletedEvent(Event) will do a urKernelRelease to update the
   // reference count on the kernel, using the kernel saved in CommandData.
   UR_CALL(urKernelRetain(Kernel));
 
@@ -678,7 +678,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferEnqueueExp(
   ZeStruct<ze_command_queue_desc_t> ZeQueueDesc;
   ZeQueueDesc.ordinal = QueueGroupOrdinal;
   CommandListPtr = CommandBuffer->CommandListMap.insert(
-      std::pair<ze_command_list_handle_t, pi_command_list_info_t>(
+      std::pair<ze_command_list_handle_t, ur_command_list_info_t>(
           CommandBuffer->ZeCommandList,
           {ZeFence, false, false, ZeCommandQueue, ZeQueueDesc}));
 

sycl/plugins/unified_runtime/ur/adapters/level_zero/command_buffer.cpp

@@ -56,9 +56,9 @@ struct ur_exp_command_buffer_handle_t_ : public _ur_object {
   // Command list map so we can use queue::executeCommandList.
   // Command list map is also used to release all the Fences retained by the
   // command_buffer std::unordered_multimap<ze_command_list_handle_t,
-  // pi_command_list_info_t> CommandListMap; CommandListMap is redefined as a
+  // ur_command_list_info_t> CommandListMap; CommandListMap is redefined as a
   // multimap to enable mutiple commands enqueing into the same command_buffer
-  std::unordered_multimap<ze_command_list_handle_t, pi_command_list_info_t>
+  std::unordered_multimap<ze_command_list_handle_t, ur_command_list_info_t>
       CommandListMap;
   // Event which will signals the most recent execution of the command-buffer
   // has finished

sycl/plugins/unified_runtime/ur/adapters/level_zero/command_buffer.hpp

@@ -336,7 +336,7 @@ struct ReferenceCounter {
   // Used when retaining an object.
   void increment() { RefCount++; }
 
-  // Supposed to be used in pi*GetInfo* methods where ref count value is
+  // Supposed to be used in ur*GetInfo* methods where ref count value is
   // requested.
   uint32_t load() { return RefCount.load(); }
 
@@ -376,7 +376,7 @@ struct _ur_object {
   // To get exclusive access to the object in a scope use std::scoped_lock:
   //    std::scoped_lock Lock(Obj->Mutex);
   //
-  // If several pi objects are accessed in a scope then each object's mutex must
+  // If several UR objects are accessed in a scope then each object's mutex must
   // be locked. For example, to get write access to Obj1 and Obj2 and read
   // access to Obj3 in a scope use the following approach:
   //   std::shared_lock Obj3Lock(Obj3->Mutex, std::defer_lock);

sycl/plugins/unified_runtime/ur/adapters/level_zero/common.hpp

@@ -323,12 +323,12 @@ ur_result_t ContextReleaseHelper(ur_context_handle_t Context) {
 
   // We must delete Context first and then destroy zeContext because
   // Context deallocation requires ZeContext in some member deallocation of
-  // pi_context.
+  // ur_context_handle_t.
   delete Context;
 
-  // Destruction of some members of pi_context uses L0 context
+  // Destruction of some members of ur_context_handle_t uses L0 context
   // and therefore it must be valid at that point.
-  // Technically it should be placed to the destructor of pi_context
+  // Technically it should be placed to the destructor of ur_context_handle_t
   // but this makes API error handling more complex.
   if (DestroyZeContext) {
     auto ZeResult = ZE_CALL_NOCHECK(zeContextDestroy, (DestroyZeContext));
@@ -345,9 +345,9 @@ ur_platform_handle_t ur_context_handle_t_::getPlatform() const {
 }
 
 ur_result_t ur_context_handle_t_::finalize() {
-  // This function is called when pi_context is deallocated, piContextRelease.
-  // There could be some memory that may have not been deallocated.
-  // For example, event and event pool caches would be still alive.
+  // This function is called when ur_context_handle_t is deallocated,
+  // urContextRelease. There could be some memory that may have not been
+  // deallocated. For example, event and event pool caches would be still alive.
 
   if (!DisableEventsCaching) {
     std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
@@ -630,7 +630,7 @@ ur_result_t ur_context_handle_t_::getAvailableCommandList(
   // the command lists, and later are then added to the command queue.
   // Each command list is paired with an associated fence to track when the
   // command list is available for reuse.
-  ur_result_t pi_result = UR_RESULT_ERROR_OUT_OF_RESOURCES;
+  ur_result_t ur_result = UR_RESULT_ERROR_OUT_OF_RESOURCES;
 
   // Initally, we need to check if a command list has already been created
   // on this device that is available for use. If so, then reuse that
@@ -678,7 +678,7 @@ ur_result_t ur_context_handle_t_::getAvailableCommandList(
         CommandList =
             Queue->CommandListMap
                 .emplace(ZeCommandList,
-                         pi_command_list_info_t{ZeFence, true, false,
+                         ur_command_list_info_t{ZeFence, true, false,
                                                 ZeCommandQueue, ZeQueueDesc})
                 .first;
       }
@@ -720,9 +720,9 @@ ur_result_t ur_context_handle_t_::getAvailableCommandList(
 
   // If there are no available command lists nor signalled command lists,
   // then we must create another command list.
-  pi_result = Queue->createCommandList(UseCopyEngine, CommandList);
+  ur_result = Queue->createCommandList(UseCopyEngine, CommandList);
   CommandList->second.ZeFenceInUse = true;
-  return pi_result;
+  return ur_result;
 }
 
 bool ur_context_handle_t_::isValidDevice(ur_device_handle_t Device) const {

sycl/plugins/unified_runtime/ur/adapters/level_zero/context.cpp

@@ -36,14 +36,15 @@ struct ur_context_handle_t_ : _ur_object {
 
   // A L0 context handle is primarily used during creation and management of
   // resources that may be used by multiple devices.
-  // This field is only set at _pi_context creation time, and cannot change.
-  // Therefore it can be accessed without holding a lock on this _pi_context.
+  // This field is only set at ur_context_handle_t creation time, and cannot
+  // change. Therefore it can be accessed without holding a lock on this
+  // ur_context_handle_t.
   const ze_context_handle_t ZeContext{};
 
   // Keep the PI devices this PI context was created for.
-  // This field is only set at _pi_context creation time, and cannot change.
-  // Therefore it can be accessed without holding a lock on this _pi_context.
-  // const std::vector<ur_device_handle_t> Devices;
+  // This field is only set at ur_context_handle_t creation time, and cannot
+  // change. Therefore it can be accessed without holding a lock on this
+  // ur_context_handle_t. const std::vector<ur_device_handle_t> Devices;
   std::vector<ur_device_handle_t> Devices;
   uint32_t NumDevices{};
 
@@ -68,8 +69,9 @@ struct ur_context_handle_t_ : _ur_object {
 
   // If context contains one device or sub-devices of the same device, we want
   // to save this device.
-  // This field is only set at _pi_context creation time, and cannot change.
-  // Therefore it can be accessed without holding a lock on this _pi_context.
+  // This field is only set at ur_context_handle_t creation time, and cannot
+  // change. Therefore it can be accessed without holding a lock on this
+  // ur_context_handle_t.
   ur_device_handle_t SingleRootDevice = nullptr;
 
   // Cache of all currently available/completed command/copy lists.
@@ -117,9 +119,9 @@ struct ur_context_handle_t_ : _ur_object {
   // Following member variables are used to manage assignment of events
   // to event pools.
   //
-  // TODO: Create pi_event_pool class to encapsulate working with pools.
+  // TODO: Create ur_event_pool class to encapsulate working with pools.
   // This will avoid needing the use of maps below, and cleanup the
-  // pi_context overall.
+  // ur_context_handle_t overall.
   //
 
   // The cache of event pools from where new events are allocated from.
@@ -179,11 +181,11 @@ struct ur_context_handle_t_ : _ur_object {
                                              bool HostVisible,
                                              bool ProfilingEnabled);
 
-  // Get pi_event from cache.
+  // Get ur_event_handle_t from cache.
   ur_event_handle_t getEventFromContextCache(bool HostVisible,
                                              bool WithProfiling);
 
-  // Add pi_event to cache.
+  // Add ur_event_handle_t to cache.
   void addEventToContextCache(ur_event_handle_t);
 
   auto getZeEventPoolCache(bool HostVisible, bool WithProfiling) {

sycl/plugins/unified_runtime/ur/adapters/level_zero/context.hpp

@@ -36,9 +36,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(
 
   // Filter available devices based on input DeviceType.
   std::vector<ur_device_handle_t> MatchedDevices;
-  std::shared_lock<ur_shared_mutex> Lock(Platform->PiDevicesCacheMutex);
-  for (auto &D : Platform->PiDevicesCache) {
-    // Only ever return root-devices from piDevicesGet, but the
+  std::shared_lock<ur_shared_mutex> Lock(Platform->URDevicesCacheMutex);
+  for (auto &D : Platform->URDevicesCache) {
+    // Only ever return root-devices from urDeviceGet, but the
     // devices cache also keeps sub-devices.
     if (D->isSubDevice())
       continue;
@@ -1274,11 +1274,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
   //
   // TODO: maybe we should populate cache of platforms if it wasn't already.
   // For now assert that is was populated.
-  UR_ASSERT(PiPlatformCachePopulated, UR_RESULT_ERROR_INVALID_VALUE);
-  const std::lock_guard<SpinLock> Lock{*PiPlatformsCacheMutex};
+  UR_ASSERT(URPlatformCachePopulated, UR_RESULT_ERROR_INVALID_VALUE);
+  const std::lock_guard<SpinLock> Lock{*URPlatformsCacheMutex};
 
   ur_device_handle_t Dev = nullptr;
-  for (ur_platform_handle_t ThePlatform : *PiPlatformsCache) {
+  for (ur_platform_handle_t ThePlatform : *URPlatformsCache) {
     Dev = ThePlatform->getDeviceFromNativeHandle(ZeDevice);
     if (Dev) {
       // Check that the input Platform, if was given, matches the found one.

sycl/plugins/unified_runtime/ur/adapters/level_zero/device.cpp

@@ -480,7 +480,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventGetProfilingInfo(
   case UR_PROFILING_INFO_COMMAND_SUBMIT:
     // Note: No users for this case
     // The "command_submit" time is implemented by recording submission
-    // timestamp with a call to piGetDeviceAndHostTimer before command enqueue.
+    // timestamp with a call to urDeviceGetGlobalTimestamps before command
+    // enqueue.
     //
     return ReturnValue(uint64_t{0});
   default:
@@ -572,7 +573,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventWait(
       {
         std::shared_lock<ur_shared_mutex> EventLock(Event->Mutex);
         if (!Event->hasExternalRefs())
-          die("piEventsWait must not be called for an internal event");
+          die("urEventWait must not be called for an internal event");
 
         if (!Event->Completed) {
           auto HostVisibleEvent = Event->HostVisibleEvent;
@@ -594,7 +595,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventWait(
               reinterpret_cast<ur_event_handle_t>(Event));
         else {
           // NOTE: we are cleaning up after the event here to free resources
-          // sooner in case run-time is not calling piEventRelease soon enough.
+          // sooner in case run-time is not calling urEventRelease soon enough.
           CleanupCompletedEvent(reinterpret_cast<ur_event_handle_t>(Event));
           // For the case when we have out-of-order queue or regular command
           // lists its more efficient to check fences so put the queue in the
@@ -679,7 +680,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventCreateWithNativeHandle(
 ) {
 
   // we dont have urEventCreate, so use this check for now to know that
-  // the call comes from piEventCreate()
+  // the call comes from urEventCreate()
   if (NativeEvent == nullptr) {
     UR_CALL(EventCreate(Context, nullptr, true, Event));
 
@@ -689,9 +690,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventCreateWithNativeHandle(
   }
 
   auto ZeEvent = ur_cast<ze_event_handle_t>(NativeEvent);
-  ur_event_handle_t_ *UrEvent{};
+  ur_event_handle_t_ *UREvent{};
   try {
-    UrEvent = new ur_event_handle_t_(ZeEvent, nullptr /* ZeEventPool */,
+    UREvent = new ur_event_handle_t_(ZeEvent, nullptr /* ZeEventPool */,
                                      Context, UR_EXT_COMMAND_TYPE_USER,
                                      Properties->isNativeHandleOwned);
 
@@ -703,16 +704,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventCreateWithNativeHandle(
 
   // Assume native event is host-visible, or otherwise we'd
   // need to create a host-visible proxy for it.
-  UrEvent->HostVisibleEvent = reinterpret_cast<ur_event_handle_t>(UrEvent);
+  UREvent->HostVisibleEvent = reinterpret_cast<ur_event_handle_t>(UREvent);
 
   // Unlike regular events managed by SYCL RT we don't have to wait for interop
   // events completion, and not need to do the their `cleanup()`. This in
-  // particular guarantees that the extra `piEventRelease` is not called on
-  // them. That release is needed to match the `piEventRetain` of regular events
+  // particular guarantees that the extra `urEventRelease` is not called on
+  // them. That release is needed to match the `urEventRetain` of regular events
   // made for waiting for event completion, but not this interop event.
-  UrEvent->CleanedUp = true;
+  UREvent->CleanedUp = true;
 
-  *Event = reinterpret_cast<ur_event_handle_t>(UrEvent);
+  *Event = reinterpret_cast<ur_event_handle_t>(UREvent);
 
   return UR_RESULT_SUCCESS;
 }
@@ -737,7 +738,7 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) {
     return UR_RESULT_SUCCESS;
 
   if (Event->CommandType == UR_COMMAND_MEM_UNMAP && Event->CommandData) {
-    // Free the memory allocated in the piEnqueueMemBufferMap.
+    // Free the memory allocated in the urEnqueueMemBufferMap.
     if (auto Res = ZeMemFreeHelper(Event->Context, Event->CommandData))
       return Res;
     Event->CommandData = nullptr;
@@ -773,9 +774,9 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) {
   }
 
   // We intentionally incremented the reference counter when an event is
-  // created so that we can avoid pi_queue is released before the associated
-  // pi_event is released. Here we have to decrement it so pi_queue
-  // can be released successfully.
+  // created so that we can avoid ur_queue_handle_t is released before the
+  // associated ur_event_handle_t is released. Here we have to decrement it so
+  // ur_queue_handle_t can be released successfully.
   if (Queue) {
     UR_CALL(urQueueReleaseInternal(Queue));
   }
@@ -839,15 +840,15 @@ ur_result_t CleanupCompletedEvent(ur_event_handle_t Event, bool QueueLocked) {
 
     // Make a list of all the dependent events that must have signalled
     // because this event was dependent on them.
-    Event->WaitList.collectEventsForReleaseAndDestroyPiZeEventList(
+    Event->WaitList.collectEventsForReleaseAndDestroyUrZeEventList(
         EventsToBeReleased);
 
     Event->CleanedUp = true;
   }
 
   auto ReleaseIndirectMem = [](ur_kernel_handle_t Kernel) {
     if (IndirectAccessTrackingEnabled) {
-      // piKernelRelease is called by CleanupCompletedEvent(Event) as soon as
+      // urKernelRelease is called by CleanupCompletedEvent(Event) as soon as
       // kernel execution has finished. This is the place where we need to
       // release memory allocations. If kernel is not in use (not submitted by
       // some other thread) then release referenced memory allocations. As a
@@ -913,7 +914,7 @@ ur_result_t CleanupCompletedEvent(ur_event_handle_t Event, bool QueueLocked) {
     ur_kernel_handle_t DepEventKernel = nullptr;
     {
       std::scoped_lock<ur_shared_mutex> DepEventLock(DepEvent->Mutex);
-      DepEvent->WaitList.collectEventsForReleaseAndDestroyPiZeEventList(
+      DepEvent->WaitList.collectEventsForReleaseAndDestroyUrZeEventList(
           EventsToBeReleased);
       if (IndirectAccessTrackingEnabled) {
         // DepEvent has finished, we can release the associated kernel if there
@@ -1220,7 +1221,7 @@ ur_result_t _ur_ze_event_list_t::insert(_ur_ze_event_list_t &Other) {
   return UR_RESULT_SUCCESS;
 }
 
-ur_result_t _ur_ze_event_list_t::collectEventsForReleaseAndDestroyPiZeEventList(
+ur_result_t _ur_ze_event_list_t::collectEventsForReleaseAndDestroyUrZeEventList(
     std::list<ur_event_handle_t> &EventsToBeReleased) {
   // event wait lists are owned by events, this function is called with owning
   // event lock taken, hence it is thread safe

sycl/plugins/unified_runtime/ur/adapters/level_zero/event.cpp

@@ -65,7 +65,7 @@ struct _ur_ze_event_list_t {
   // List of level zero events for this event list.
   ze_event_handle_t *ZeEventList = {nullptr};
 
-  // List of pi_events for this event list.
+  // List of ur_events for this event list.
   ur_event_handle_t *UrEventList = {nullptr};
 
   // length of both the lists.  The actual allocation of these lists
@@ -74,8 +74,8 @@ struct _ur_ze_event_list_t {
   uint32_t Length = {0};
 
   // Initialize this using the array of events in EventList, and retain
-  // all the pi_events in the created data structure.
-  // CurQueue is the pi_queue that the command with this event wait
+  // all the ur_event_handle_t in the created data structure.
+  // CurQueue is the ur_queue_handle_t that the command with this event wait
   // list is going to be added to.  That is needed to flush command
   // batches for wait events that are in other queues.
   // UseCopyEngine indicates if the next command (the one that this
@@ -88,9 +88,9 @@ struct _ur_ze_event_list_t {
                                            bool UseCopyEngine);
 
   // Add all the events in this object's UrEventList to the end
-  // of the list EventsToBeReleased. Destroy pi_ze_event_list_t data
+  // of the list EventsToBeReleased. Destroy ur_ze_event_list_t data
   // structure fields making it look empty.
-  ur_result_t collectEventsForReleaseAndDestroyPiZeEventList(
+  ur_result_t collectEventsForReleaseAndDestroyUrZeEventList(
       std::list<ur_event_handle_t> &EventsToBeReleased);
 
   // Had to create custom assignment operator because the mutex is
@@ -163,7 +163,7 @@ struct ur_event_handle_t_ : _ur_object {
   // Opaque data to hold any data needed for CommandType.
   void *CommandData;
 
-  // Command list associated with the pi_event.
+  // Command list associated with the ur_event_handle_t
   std::optional<ur_command_list_ptr_t> CommandList;
 
   // List of events that were in the wait list of the command that will
@@ -206,7 +206,7 @@ struct ur_event_handle_t_ : _ur_object {
 
   bool hasExternalRefs() { return RefCountExternal != 0; }
 
-  // Reset _pi_event object.
+  // Reset ur_event_handle_t object.
   ur_result_t reset();
 
   // Tells if this event is with profiling capabilities.

sycl/plugins/unified_runtime/ur/adapters/level_zero/event.hpp

@@ -196,12 +196,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueKernelLaunch(
   (*Event)->WaitList = TmpWaitList;
 
   // Save the kernel in the event, so that when the event is signalled
-  // the code can do a piKernelRelease on this kernel.
+  // the code can do a urKernelRelease on this kernel.
   (*Event)->CommandData = (void *)Kernel;
 
   // Increment the reference count of the Kernel and indicate that the Kernel is
   // in use. Once the event has been signalled, the code in
-  // CleanupCompletedEvent(Event) will do a piReleaseKernel to update the
+  // CleanupCompletedEvent(Event) will do a urKernelRelease to update the
   // reference count on the kernel, using the kernel saved in CommandData.
   UR_CALL(urKernelRetain(Kernel));