Changes USMShared memory allocation for host only allocation

Author: mfrancepillois

source/adapters/level_zero/command_buffer.cpp

@@ -939,51 +939,42 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferEnqueueExp(
   // Create a command-list to signal RetEvent on completion
   ur_command_list_ptr_t SignalCommandList{};
   if (Event) {
+    ur_event_handle_t SyncEvent = CommandBuffer->SignalEvent;
     UR_CALL(Queue->Context->getAvailableCommandList(Queue, SignalCommandList,
                                                     false, false));
 
     UR_CALL(createEventAndAssociateQueue(Queue, &RetEvent,
                                          UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP,
                                          SignalCommandList, false));
 
-    ZE2UR_CALL(zeCommandListAppendBarrier,
-               (SignalCommandList->first, RetEvent->ZeEvent, 1,
-                &(CommandBuffer->SignalEvent->ZeEvent)));
-
     if ((Queue->Properties & UR_QUEUE_FLAG_PROFILING_ENABLE)) {
       // Multiple submissions of a command buffer implies that we need to save
       // the event timestamps before resubmiting the command buffer. We
       // therefore copy the these timestamps in a dedicated USM memory section
       // before completing the command buffer execution, and then attach this
       // memory to the event returned to users to allow to allow the profiling
       // engine to recover these timestamps.
-      ur_usm_desc_t USMDesc{};
-      ur_usm_device_desc_t UsmDeviceDesc{};
-      UsmDeviceDesc.stype = UR_STRUCTURE_TYPE_USM_DEVICE_DESC;
-      ur_usm_host_desc_t UsmHostDesc{};
-      UsmHostDesc.stype = UR_STRUCTURE_TYPE_USM_HOST_DESC;
-      UsmDeviceDesc.pNext = &UsmHostDesc;
-      USMDesc.pNext = &UsmDeviceDesc;
-      USMDesc.align = 4; // 4byte-aligned
-
-      size_t Size = WaitEventList.size() * sizeof(ze_kernel_timestamp_result_t);
+      UR_CALL(createEventAndAssociateQueue(
+          Queue, &SyncEvent, UR_COMMAND_USM_MEMCPY, SignalCommandList, false));
 
-      struct command_buffer_profiling_t *Profiling =
-          new command_buffer_profiling_t();
+      command_buffer_profiling_t *Profiling = new command_buffer_profiling_t();
 
       Profiling->NumEvents = WaitEventList.size();
-
-      urUSMSharedAlloc(RetEvent->Context, CommandBuffer->Device, &USMDesc,
-                       nullptr, Size, (void **)&Profiling->Timestamps);
+      Profiling->Timestamps =
+          new ze_kernel_timestamp_result_t[Profiling->NumEvents];
 
       ZE2UR_CALL(zeCommandListAppendQueryKernelTimestamps,
                  (SignalCommandList->first, WaitEventList.size(),
-                  WaitEventList.data(), Profiling->Timestamps, 0,
-                  RetEvent->ZeEvent, 1,
+                  WaitEventList.data(), (void *)Profiling->Timestamps, 0,
+                  SyncEvent->ZeEvent, 1,
                   &(CommandBuffer->SignalEvent->ZeEvent)));
 
       RetEvent->CommandData = static_cast<void *>(Profiling);
     }
+
+    ZE2UR_CALL(zeCommandListAppendBarrier,
+               (SignalCommandList->first, RetEvent->ZeEvent, 1,
+                &(SyncEvent->ZeEvent)));
   }
 
   // Execution our command-lists asynchronously

source/adapters/level_zero/event.cpp

@@ -480,14 +480,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventGetProfilingInfo(
   // from this memory.
   if (Event->CommandType == UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP) {
     if (Event->CommandData) {
-      struct command_buffer_profiling_t *ProfilingsPtr;
+      command_buffer_profiling_t *ProfilingsPtr;
       switch (PropName) {
       case UR_PROFILING_INFO_COMMAND_START: {
-        ProfilingsPtr = static_cast<struct command_buffer_profiling_t *>(
-            Event->CommandData);
+        ProfilingsPtr =
+            static_cast<command_buffer_profiling_t *>(Event->CommandData);
         // Sync-point order does not necessarily match to the order of
         // execution. We therefore look for the first command executed.
-        uint64_t MinStart = ProfilingsPtr->Timestamps->global.kernelStart;
+        uint64_t MinStart = ProfilingsPtr->Timestamps[0].global.kernelStart;
         for (uint64_t i = 1; i < ProfilingsPtr->NumEvents; i++) {
           uint64_t Timestamp = ProfilingsPtr->Timestamps[i].global.kernelStart;
           if (Timestamp < MinStart) {
@@ -499,12 +499,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventGetProfilingInfo(
         return ReturnValue(ContextStartTime);
       }
       case UR_PROFILING_INFO_COMMAND_END: {
-        ProfilingsPtr = static_cast<struct command_buffer_profiling_t *>(
-            Event->CommandData);
+        ProfilingsPtr =
+            static_cast<command_buffer_profiling_t *>(Event->CommandData);
         // Sync-point order does not necessarily match to the order of
         // execution. We therefore look for the last command executed.
-        uint64_t MaxEnd = ProfilingsPtr->Timestamps->global.kernelEnd;
-        uint64_t LastStart = ProfilingsPtr->Timestamps->global.kernelStart;
+        uint64_t MaxEnd = ProfilingsPtr->Timestamps[0].global.kernelEnd;
+        uint64_t LastStart = ProfilingsPtr->Timestamps[0].global.kernelStart;
         for (uint64_t i = 1; i < ProfilingsPtr->NumEvents; i++) {
           uint64_t Timestamp = ProfilingsPtr->Timestamps[i].global.kernelEnd;
           if (Timestamp > MaxEnd) {
@@ -832,9 +832,9 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) {
   if (Event->CommandType == UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP &&
       Event->CommandData) {
     // Free the memory extra event allocated for profiling purposed.
-    struct command_buffer_profiling_t *ProfilingPtr =
-        static_cast<struct command_buffer_profiling_t *>(Event->CommandData);
-    urUSMFree(Event->Context, (void *)ProfilingPtr->Timestamps);
+    command_buffer_profiling_t *ProfilingPtr =
+        static_cast<command_buffer_profiling_t *>(Event->CommandData);
+    delete[] ProfilingPtr->Timestamps;
     delete ProfilingPtr;
     Event->CommandData = nullptr;
   }