Removed explicit sync where necessary

Author: konradkusiak97

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

@@ -387,9 +387,6 @@ urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
 UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
   if (hCommandBuffer->decrementReferenceCount() == 0) {
-    if (hCommandBuffer->CurrentExecution) {
-      UR_CHECK_ERROR(hCommandBuffer->CurrentExecution->wait());
-    }
     // Ref count has reached zero, release of created commands
     for (auto &Command : hCommandBuffer->CommandHandles) {
       commandHandleDestroy(Command);
@@ -1172,10 +1169,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueCommandBufferExp(
   // Launch graph
   UR_CHECK_ERROR(cuGraphLaunch(hCommandBuffer->CudaGraphExec, CuStream));
 
-  UR_CHECK_ERROR(RetImplEvent->record());
-  hCommandBuffer->CurrentExecution = RetImplEvent.release();
   if (phEvent) {
-    *phEvent = hCommandBuffer->CurrentExecution;
+    UR_CHECK_ERROR(RetImplEvent->record());
+    *phEvent = RetImplEvent.release();
   }
   return UR_RESULT_SUCCESS;
 } catch (ur_result_t Err) {

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

@@ -192,8 +192,6 @@ struct ur_exp_command_buffer_handle_t_ : ur::cuda::handle_base {
   // Atomic variable counting the number of reference to this command_buffer
   // using std::atomic prevents data race when incrementing/decrementing.
   std::atomic_uint32_t RefCount;
-  // Track the event of the current graph execution.
-  ur_event_handle_t CurrentExecution = nullptr;
 
   // Ordered map of sync_points to ur_events, so that we can find the last
   // node added to an in-order command-buffer.

unified-runtime/source/adapters/hip/command_buffer.cpp

@@ -273,9 +273,6 @@ urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
 UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
   if (hCommandBuffer->decrementReferenceCount() == 0) {
-    if (hCommandBuffer->CurrentExecution) {
-      UR_CHECK_ERROR(hCommandBuffer->CurrentExecution->wait());
-    }
     delete hCommandBuffer;
   }
   return UR_RESULT_SUCCESS;
@@ -811,10 +808,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueCommandBufferExp(
     // Launch graph
     UR_CHECK_ERROR(hipGraphLaunch(hCommandBuffer->HIPGraphExec, HIPStream));
 
-    UR_CHECK_ERROR(RetImplEvent->record());
-    hCommandBuffer->CurrentExecution = RetImplEvent.release();
     if (phEvent) {
-      *phEvent = hCommandBuffer->CurrentExecution;
+      UR_CHECK_ERROR(RetImplEvent->record());
+      *phEvent = RetImplEvent.release();
     }
   } catch (ur_result_t Err) {
     return Err;

unified-runtime/source/adapters/hip/command_buffer.hpp

@@ -128,8 +128,6 @@ struct ur_exp_command_buffer_handle_t_ : ur::hip::handle_base {
   // Atomic variable counting the number of reference to this command_buffer
   // using std::atomic prevents data race when incrementing/decrementing.
   std::atomic_uint32_t RefCount;
-  // Track the event of the current graph execution.
-  ur_event_handle_t CurrentExecution = nullptr;
 
   // Ordered map of sync_points to ur_events
   std::map<ur_exp_command_buffer_sync_point_t, hipGraphNode_t> SyncPoints;

unified-runtime/source/adapters/level_zero/command_buffer.cpp

@@ -672,12 +672,12 @@ ur_result_t createMainCommandList(ur_context_handle_t Context,
 }
 
 /**
- * Waits for any ongoing executions of the command-buffer to finish.
+ * Waits for any ongoing executions of the command-buffer to finish
  * @param CommandBuffer The command-buffer to wait for.
  * @return UR_RESULT_SUCCESS or an error code on failure
  */
 ur_result_t
-waitForLastSubmission(ur_exp_command_buffer_handle_t CommandBuffer) {
+waitForOngoingExecution(ur_exp_command_buffer_handle_t CommandBuffer) {
 
   if (ur_event_handle_t &CurrentSubmissionEvent =
           CommandBuffer->CurrentSubmissionEvent) {
@@ -690,30 +690,6 @@ waitForLastSubmission(ur_exp_command_buffer_handle_t CommandBuffer) {
   return UR_RESULT_SUCCESS;
 }
 
-/**
- * Waits for any ongoing executions of the command-buffer to finish
- * but put fence in case of wait event path.
- * @param CommandBuffer The command-buffer to wait for.
- * @return UR_RESULT_SUCCESS or an error code on failure
- */
-ur_result_t
-waitForOngoingExecution(ur_exp_command_buffer_handle_t CommandBuffer) {
-
-  if (CommandBuffer->UseImmediateAppendPath) {
-    if (ur_event_handle_t &CurrentSubmissionEvent =
-            CommandBuffer->CurrentSubmissionEvent) {
-      ZE2UR_CALL(zeEventHostSynchronize,
-                 (CurrentSubmissionEvent->ZeEvent, UINT64_MAX));
-      UR_CALL(urEventReleaseInternal(CurrentSubmissionEvent));
-      CurrentSubmissionEvent = nullptr;
-    }
-  } else if (ze_fence_handle_t &ZeFence = CommandBuffer->ZeActiveFence) {
-    ZE2UR_CALL(zeFenceHostSynchronize, (ZeFence, UINT64_MAX));
-  }
-
-  return UR_RESULT_SUCCESS;
-}
-
 /**
  * Checks whether the command-buffer can be constructed using in order
  * command-lists.
@@ -1767,7 +1743,7 @@ ur_result_t urEnqueueCommandBufferExp(
 
   std::scoped_lock<ur_shared_mutex> Lock(UrQueue->Mutex);
 
-  UR_CALL(waitForLastSubmission(CommandBuffer));
+  UR_CALL(waitForOngoingExecution(CommandBuffer));
 
   const bool IsInternal = (Event == nullptr);
   const bool DoProfiling =

unified-runtime/source/adapters/opencl/command_buffer.cpp

@@ -115,10 +115,6 @@ urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
 UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
   if (hCommandBuffer->decrementReferenceCount() == 0) {
-    if (hCommandBuffer->LastSubmission) {
-      cl_int RetErr = clWaitForEvents(1, &(hCommandBuffer->LastSubmission));
-      CL_RETURN_ON_FAILURE(RetErr);
-    }
     delete hCommandBuffer;
   }
 

unified-runtime/test/conformance/exp_command_buffer/enqueue.cpp

@@ -194,12 +194,12 @@ TEST_P(urEnqueueCommandBufferExpTest, SerializeInOrOutOfOrderQueue) {
 // Tests releasing command-buffer while it is still executing relying
 // on synchronization during urCommandBufferReleaseExp call.
 TEST_P(urEnqueueCommandBufferExpTest, EnqueueAndRelease) {
-  ASSERT_SUCCESS(urEnqueueCommandBufferExp(out_of_order_queue, cmd_buf_handle,
-                                           0, nullptr, nullptr));
+  ASSERT_SUCCESS(urEnqueueCommandBufferExp(
+      in_or_out_of_order_queue, cmd_buf_handle, 0, nullptr, nullptr));
 
   // Release the command buffer without explicitly waiting beforehand
   EXPECT_SUCCESS(urCommandBufferReleaseExp(cmd_buf_handle));
 
   // Wait before exiting
-  ASSERT_SUCCESS(urQueueFinish(out_of_order_queue));
+  ASSERT_SUCCESS(urQueueFinish(in_or_out_of_order_queue));
 }