use synchronous host wait for zeHandle copies

This workarounds the problems with adding waitlist events
to the copy immediate command list.

source/adapters/level_zero/memory.cpp

@@ -2175,17 +2175,10 @@ ur_result_t _ur_buffer::getZeHandle(char *&ZeHandle, access_mode_t AccessMode,
     }
 
     if (NeedCopy) {
-
-      // Generate the waitlist for the Copy calls based on the passed in
-      // dependencies, if they exist.
-      _ur_ze_event_list_t waitlist;
-      waitlist.ZeEventList = nullptr;
-      waitlist.Length = numWaitEvents;
-      if (numWaitEvents != 0) {
-        waitlist.ZeEventList = new ze_event_handle_t[numWaitEvents];
-        for (uint32_t i = 0; i < numWaitEvents; i++) {
-          waitlist.ZeEventList[i] = phWaitEvents[i]->ZeEvent;
-        }
+      // Wait for all events synchronously to make sure that the copy
+      // operates on the correct data.
+      for (unsigned i = 0; i < numWaitEvents; ++i) {
+        ZE2UR_CALL(zeHostSynchronize, (phWaitEvents[i]->ZeEvent));
       }
 
       // Copy valid buffer data to this allocation.
@@ -2225,26 +2218,24 @@ ur_result_t _ur_buffer::getZeHandle(char *&ZeHandle, access_mode_t AccessMode,
         if (!HostAllocation.Valid) {
           ZE2UR_CALL(zeCommandListAppendMemoryCopy,
                      (UrContext->ZeCommandListInit, HostAllocation.ZeHandle,
-                      ZeHandleSrc, Size, nullptr, waitlist.Length,
-                      waitlist.ZeEventList));
+                      ZeHandleSrc, Size, nullptr, 0,
+                      nullptr));
           // Mark the host allocation data  as valid so it can be reused.
           // It will be invalidated below if the current access is not
           // read-only.
           HostAllocation.Valid = true;
         }
         ZE2UR_CALL(zeCommandListAppendMemoryCopy,
                    (UrContext->ZeCommandListInit, ZeHandle,
-                    HostAllocation.ZeHandle, Size, nullptr, waitlist.Length,
-                    waitlist.ZeEventList));
+                    HostAllocation.ZeHandle, Size, nullptr, 0,
+                    nullptr));
       } else {
         // Perform P2P copy.
         std::scoped_lock<ur_mutex> Lock(UrContext->ImmediateCommandListMutex);
         ZE2UR_CALL(zeCommandListAppendMemoryCopy,
                    (UrContext->ZeCommandListInit, ZeHandle, ZeHandleSrc, Size,
-                    nullptr, waitlist.Length, waitlist.ZeEventList));
+                    nullptr, 0, nullptr));
       }
-      if (waitlist.ZeEventList)
-        delete waitlist.ZeEventList;
     }
     Allocation.Valid = true;
     LastDeviceWithValidAllocation = Device;