fix stack sync for cb events

Author: mateuszpn

unified-runtime/source/adapters/level_zero/v2/command_list_manager.cpp

@@ -36,18 +36,26 @@ ur_result_t ur_command_list_manager::appendGenericFillUnlocked(
       hDevice.get(), ur_mem_buffer_t::device_access_mode_t::read_only, offset,
       size, zeCommandList.get(), waitListView));
 
+  // Store pattern in event if this is an async operation
+  // This prevents use-after-return bug when pPattern points to stack memory
+  const void *patternPtr = pPattern;
+  if (phEvent && zeSignalEvent) {
+    phEvent->retainFillPattern(pPattern, patternSize);
+    patternPtr = phEvent->getFillPattern();
+  }
+
   // PatternSize must be a power of two for zeCommandListAppendMemoryFill.
   // When it's not, the fill is emulated with zeCommandListAppendMemoryCopy.
   // WORKAROUND: Level Zero driver rejects zeCommandListAppendMemoryFill when
   // patternSize == size, returning ZE_RESULT_ERROR_INVALID_SIZE (0x78000008).
   if (isPowerOf2(patternSize) && patternSize != size) {
     ZE2UR_CALL(zeCommandListAppendMemoryFill,
-               (zeCommandList.get(), pDst, pPattern, patternSize, size,
+               (zeCommandList.get(), pDst, patternPtr, patternSize, size,
                 zeSignalEvent, waitListView.num, waitListView.handles));
   } else {
     // Copy pattern into every entry in memory array pointed by Ptr.
     uint32_t numOfCopySteps = size / patternSize;
-    const void *src = pPattern;
+    const void *src = patternPtr;
 
     for (uint32_t step = 0; step < numOfCopySteps; ++step) {
       void *dst = reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(pDst) +

unified-runtime/source/adapters/level_zero/v2/event.cpp

@@ -141,12 +141,41 @@ uint64_t ur_event_handle_t_::getEventEndTimestamp() {
   return profilingData.getEventEndTimestamp();
 }
 
+void ur_event_handle_t_::retainFillPattern(const void *pPattern, size_t patternSize) {
+  if (!fillPattern) {
+    fillPattern.emplace();
+  }
+  
+  auto &storage = fillPattern.value();
+  storage.size = patternSize;
+  
+  // Small buffer optimization: use inline buffer for patterns <= 16 bytes
+  if (patternSize <= FillPatternStorage::INLINE_SIZE) {
+    std::memcpy(storage.inlineBuffer.data(), pPattern, patternSize);
+    storage.useHeap = false;
+  } else {
+    // Use heap buffer for larger patterns
+    storage.heapBuffer.resize(patternSize);
+    std::memcpy(storage.heapBuffer.data(), pPattern, patternSize);
+    storage.useHeap = true;
+  }
+}
+
+const void *ur_event_handle_t_::getFillPattern() const {
+  if (!fillPattern) {
+    return nullptr;
+  }
+  return fillPattern->data();
+}
+
 void ur_event_handle_t_::reset() {
   // consider make an abstraction for regular/counter based
   // events if there's more of this type of conditions
   if (!(flags & v2::EVENT_FLAGS_COUNTER)) {
     zeEventHostReset(getZeEvent());
   }
+  // Clear the fill pattern to avoid memory leak when event is reused from pool
+  fillPattern.reset();
 }
 
 ze_event_handle_t ur_event_handle_t_::getZeEvent() const {

unified-runtime/source/adapters/level_zero/v2/event.hpp

@@ -9,7 +9,10 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
+#include <array>
+#include <optional>
 #include <stack>
+#include <vector>
 
 #include <ur/ur.hpp>
 #include <ur_api.h>
@@ -83,6 +86,12 @@ struct ur_event_handle_t_ : ur_object {
   // deffered events list in the queue
   ur_result_t releaseDeferred();
 
+  // Store pattern data for USM fill commands to keep it alive
+  void retainFillPattern(const void *pPattern, size_t patternSize);
+
+  // Get pointer to the retained fill pattern data
+  const void *getFillPattern() const;
+
   // Tells if this event was created as a timestamp event, allowing profiling
   // info even if profiling is not enabled.
   bool isTimestamped() const;
@@ -135,4 +144,20 @@ struct ur_event_handle_t_ : ur_object {
 
   v2::event_flags_t flags;
   event_profiling_data_t profilingData;
+
+  // Storage for fill pattern to keep it alive during async execution
+  // Uses std::optional to avoid overhead for non-fill events
+  // Small buffer optimization: patterns ≤16 bytes use inline storage
+  struct FillPatternStorage {
+    static constexpr size_t INLINE_SIZE = 16;
+    std::array<uint8_t, INLINE_SIZE> inlineBuffer;
+    std::vector<uint8_t> heapBuffer;
+    size_t size = 0;
+    bool useHeap = false;
+    
+    const void* data() const {
+      return useHeap ? heapBuffer.data() : inlineBuffer.data();
+    }
+  };
+  std::optional<FillPatternStorage> fillPattern;
 };