[E2E][ARC] Plugin/enqueue-arg-order-image.cpp timed out on Arc

[uditagarwal97]

Describe the bug

Failure: https://github.com/intel/llvm/actions/runs/8803471729/job/24162956072?pr=13526#step:21:49

# error: command failed with exit status: -9
# error: command reached timeout: True
# executed command: /__w/llvm/llvm/toolchain/bin/FileCheck /__w/llvm/llvm/llvm/sycl/test-e2e/Plugin/enqueue-arg-order-image.cpp
# note: command had no output on stdout or stderr
# error: command failed with exit status: -9
# error: command reached timeout: True

To reproduce

DPC++ commit id: 51c765e

Environment

OS: Linux (have not tested on Windows)

Additional context

sycl-ls --verbose output:

Devices  : 1
        Device [#0]:
        Type       : gpu
        Version    : OpenCL 3.0 NEO 
        Name       : Intel(R) Arc(TM) A750 Graphics
        Vendor     : Intel(R) Corporation
        Driver     : 24.05.28454.6

[AlexeySachkov]

I see a timeout in this test on PVC in pre-commit for #20151:

Env:

[level_zero:gpu][level_zero:0] Intel(R) oneAPI Unified Runtime over Level-Zero, Intel(R) Data Center GPU Max 1100 12.60.7 [1.6.34666.300000]
[native_cpu:cpu][native_cpu:0] SYCL_NATIVE_CPU, SYCL Native CPU 0.1 [0.0.0]
[opencl:cpu][opencl:0] Intel(R) OpenCL, INTEL(R) XEON(R) PLATINUM 8580 OpenCL 3.0 (Build 0) [2025.20.6.0.04_224945]
[opencl:gpu][opencl:1] Intel(R) OpenCL Graphics, Intel(R) Data Center GPU Max 1100 OpenCL 3.0 NEO  [25.31.34666.3]

Log:

 TIMEOUT: SYCL :: Adapters/enqueue-arg-order-buffer.cpp (1894 of 1894)
  ******************** TEST 'SYCL :: Adapters/enqueue-arg-order-buffer.cpp' FAILED ********************
  Exit Code: -9
  Timeout: Reached timeout of 300 seconds
  
  Command Output (stdout):
  --
  # RUN: at line 2
  env SYCL_UR_TRACE=2 env ONEAPI_DEVICE_SELECTOR=level_zero:gpu  /__w/llvm/llvm/build-e2e/Adapters/Output/enqueue-arg-order-buffer.cpp.tmp.out | /__w/llvm/llvm/toolchain/bin/FileCheck /__w/llvm/llvm/llvm/sycl/test-e2e/Adapters/enqueue-arg-order-buffer.cpp
  # executed command: env SYCL_UR_TRACE=2 env ONEAPI_DEVICE_SELECTOR=level_zero:gpu /__w/llvm/llvm/build-e2e/Adapters/Output/enqueue-arg-order-buffer.cpp.tmp.out
  # .---command stderr------------
  # | UR ---> platform->initialize()
  # | UR <--- platform->initialize()(UR_RESULT_SUCCESS)
  # | UR ---> Device->initialize()
  # | UR <--- Device->initialize()(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> (*RetKernel)->initialize()
  # | UR ---> ur::level_zero::urProgramRetain(Program)
  # | UR <--- ur::level_zero::urProgramRetain(Program)(UR_RESULT_SUCCESS)
  # | UR <--- (*RetKernel)->initialize()(UR_RESULT_SUCCESS)
  # | UR ---> getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)
  # | UR <--- getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)
  # | UR ---> getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)
  # | UR <--- getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)(UR_RESULT_SUCCESS)
  # | UR <--- calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urKernelRetain(Kernel)
  # | UR <--- ur::level_zero::urKernelRetain(Kernel)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, false , true )
  # | UR <--- Queue->executeCommandList(CommandList, false , true )(UR_RESULT_SUCCESS)
  # | UR ---> Src->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR <--- Src->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, BlockingWrite, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(DepEvent)
  # | UR <--- urEventReleaseInternal(DepEvent)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> ur::level_zero::urKernelRelease(AssociatedKernel)
  # | UR <--- ur::level_zero::urKernelRelease(AssociatedKernel)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->synchronize()
  # | UR <--- Queue->synchronize()(UR_RESULT_SUCCESS)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> (*RetKernel)->initialize()
  # | UR ---> ur::level_zero::urProgramRetain(Program)
  # | UR <--- ur::level_zero::urProgramRetain(Program)(UR_RESULT_SUCCESS)
  # | UR <--- (*RetKernel)->initialize()(UR_RESULT_SUCCESS)
  # | UR ---> getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)
  # | UR <--- getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)
  # | UR ---> getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)
  # | UR <--- getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)(UR_RESULT_SUCCESS)
  # | UR <--- calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urKernelRetain(Kernel)
  # | UR <--- ur::level_zero::urKernelRetain(Kernel)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, false , true )
  # | UR <--- Queue->executeCommandList(CommandList, false , true )(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR <--- Buffer->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(DepEvent)
  # | UR <--- urEventReleaseInternal(DepEvent)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> ur::level_zero::urKernelRelease(AssociatedKernel)
  # | UR <--- ur::level_zero::urKernelRelease(AssociatedKernel)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->synchronize()
  # | UR <--- Queue->synchronize()(UR_RESULT_SUCCESS)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # | UR <--- ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))(UR_RESULT_SUCCESS)
  # | UR <--- Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> (*RetKernel)->initialize()
  # | UR ---> ur::level_zero::urProgramRetain(Program)
  # | UR <--- ur::level_zero::urProgramRetain(Program)(UR_RESULT_SUCCESS)
  # | UR <--- (*RetKernel)->initialize()(UR_RESULT_SUCCESS)
  # | UR ---> getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)
  # | UR <--- getZeKernel(Queue->Device->ZeDevice, Kernel, &ZeKernel)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)
  # | UR ---> getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)
  # | UR <--- getZeHandle(ZeHandle, AccessMode, Device, phWaitEvents, numWaitEvents)(UR_RESULT_SUCCESS)
  # | UR <--- Arg.Value->getZeHandlePtr(ZeHandlePtr, Arg.AccessMode, Queue->Device, EventWaitList, NumEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)
  # | UR ---> getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)
  # | UR <--- getSuggestedLocalWorkSize(Device, Kernel, GlobalWorkSize3D, WG)(UR_RESULT_SUCCESS)
  # | UR <--- calculateKernelWorkDimensions(Kernel->ZeKernel, Queue->Device, ZeThreadGroupDimensions, WG, WorkDim, GlobalWorkSize, LocalWorkSize)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, true , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, UR_COMMAND_KERNEL_LAUNCH, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urKernelRetain(Kernel)
  # | UR <--- ur::level_zero::urKernelRetain(Kernel)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, false , true )
  # | UR <--- Queue->executeCommandList(CommandList, false , true )(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR <--- Buffer->getZeHandle(ZeHandleSrc, ur_mem_handle_t_::read_only, Queue->Device, phEventWaitList, numEventsInWaitList)(UR_RESULT_SUCCESS)
  # | UR ---> TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)
  # | UR <--- TmpWaitList.createAndRetainUrZeEventList( NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )
  # | UR ---> Queue->insertStartBarrierIfDiscardEventsMode(CommandList)
  # | UR <--- Queue->insertStartBarrierIfDiscardEventsMode(CommandList)(UR_RESULT_SUCCESS)
  # | UR <--- Queue->Context->getAvailableCommandList( Queue, CommandList, UseCopyEngine, NumEventsInWaitList, EventWaitList, OkToBatch, nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)
  # | UR ---> EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)
  # | UR <--- EventCreate( Queue->Context, Queue, IsMultiDevice, HostVisible.value(), Event, Queue->CounterBasedEventsEnabled, false , Queue->InterruptBasedEventsEnabled, IsInternal)(UR_RESULT_SUCCESS)
  # | UR ---> ur::level_zero::urEventRetain(*Event)
  # | UR <--- ur::level_zero::urEventRetain(*Event)(UR_RESULT_SUCCESS)
  # | UR <--- createEventAndAssociateQueue(Queue, Event, CommandType, CommandList, IsInternal, false)(UR_RESULT_SUCCESS)
  # | UR ---> setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)
  # | UR <--- setSignalEvent(Queue, UseCopyEngine, &ZeEvent, Event, NumEventsInWaitList, EventWaitList, CommandList->second.ZeQueue)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->executeCommandList(CommandList, Blocking, OkToBatch)
  # | UR <--- Queue->executeCommandList(CommandList, Blocking, OkToBatch)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(DepEvent)
  # | UR <--- urEventReleaseInternal(DepEvent)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR ---> ur::level_zero::urKernelRelease(AssociatedKernel)
  # | UR <--- ur::level_zero::urKernelRelease(AssociatedKernel)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR ---> CleanupCompletedEvent(Event, QueueLocked, true )
  # | UR <--- CleanupCompletedEvent(Event, QueueLocked, true )(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event)
  # | UR <--- urEventReleaseInternal(Event)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> UrQueue->executeAllOpenCommandLists()
  # | UR <--- UrQueue->executeAllOpenCommandLists()(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventsInImmCmdLists(Queue, true , false , nullptr )
  # | UR ---> UrQueue->resetCommandList(It, true, EventListToCleanup, true )
  # | UR <--- UrQueue->resetCommandList(It, true, EventListToCleanup, true )(UR_RESULT_SUCCESS)
  # | UR ---> CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)
  # | UR <--- CleanupEventListFromResetCmdList(EventListToCleanup, QueueLocked)(UR_RESULT_SUCCESS)
  # | UR <--- CleanupEventsInImmCmdLists(Queue, true , false , nullptr )(UR_RESULT_SUCCESS)
  # | UR ---> USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)
  # | UR <--- USMFreeHelper(reinterpret_cast<ur_context_handle_t>(UrContext), ZeHandle)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> urEventReleaseInternal(Event, &isEventDeleted)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR <--- urEventReleaseInternal(Event, &isEventDeleted)(UR_RESULT_SUCCESS)
  # | UR ---> Queue->synchronize()
  # | UR <--- Queue->synchronize()(UR_RESULT_SUCCESS)
  # | UR ---> urQueueReleaseInternal(Queue)
  # | UR <--- urQueueReleaseInternal(Queue)(UR_RESULT_SUCCESS)
  # | UR ---> Buffer->getZeHandle(ZeHandleDst, ur_mem_handle_t_::write_only, Queue->Device, phEventWaitList, numEventsInWaitList)
  # | UR ---> ur::level_zero::urUSMDeviceAlloc( UrContext, Device, &USMDesc, Pool, Size, reinterpret_cast<void **>(&ZeHandle))
  # `-----------------------------
  # error: command failed with exit status: -9
  # error: command reached timeout: True
  # executed command: /__w/llvm/llvm/toolchain/bin/FileCheck /__w/llvm/llvm/llvm/sycl/test-e2e/Adapters/enqueue-arg-order-buffer.cpp
  # note: command had no output on stdout or stderr
  # error: command failed with exit status: -9
  # error: command reached timeout: True
  
  --