completion of copy-back path

Signed-off-by: Mateusz P. Nowak <mateusz.p.nowak@intel.com>

Author: mateuszpn

sycl/test-e2e/lit.cfg.py

@@ -1112,6 +1112,7 @@ def get_sycl_ls_verbose(sycl_device, env):
     features.update(sg_size_features)
     features.update(architecture_feature)
     features.update(device_family)
+    features.update(aspects)
 
     be, dev = sycl_device.split(":")
     features.add(dev.replace("fpga", "accelerator"))

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

@@ -66,7 +66,6 @@ ur_integrated_buffer_handle_t::ur_integrated_buffer_handle_t(
     if (ret == UR_RESULT_SUCCESS && memProps.type != ZE_MEMORY_TYPE_UNKNOWN) {
       // Already a USM allocation - just use it directly without import
       this->ptr = usm_unique_ptr_t(hostPtr, [](void *) {});
-      // No copy-back needed for USM pointers
       return;
     }
 
@@ -134,16 +133,52 @@ void *ur_integrated_buffer_handle_t::getDevicePtr(
 }
 
 void *ur_integrated_buffer_handle_t::mapHostPtr(
-    ur_map_flags_t /*flags*/, size_t offset, size_t /*size*/,
+    ur_map_flags_t flags, size_t offset, size_t mapSize,
     ze_command_list_handle_t /*cmdList*/, wait_list_view & /*waitListView*/) {
-  // For integrated devices, both device and host access the same memory
+  if (writeBackPtr) {
+    // Copy-back path: user gets back their original pointer
+    void *mappedPtr = ur_cast<char *>(writeBackPtr) + offset;
+    
+    if (flags & UR_MAP_FLAG_READ) {
+      std::memcpy(mappedPtr, ur_cast<char *>(ptr.get()) + offset, mapSize);
+    }
+    
+    // Track this mapping for unmap
+    mappedRegions.emplace_back(
+        usm_unique_ptr_t(mappedPtr, [](void *) {}), mapSize, offset, flags);
+    
+    return mappedPtr;
+  }
+  
+  // Zero-copy path: for successfully imported or USM pointers
   return ur_cast<char *>(ptr.get()) + offset;
 }
 
 void ur_integrated_buffer_handle_t::unmapHostPtr(
-    void * /*pMappedPtr*/, ze_command_list_handle_t /*cmdList*/,
+    void *pMappedPtr, ze_command_list_handle_t /*cmdList*/,
     wait_list_view & /*waitListView*/) {
-  // No-op: integrated buffers use zero-copy, no synchronization needed
+  if (writeBackPtr) {
+    // Copy-back path: find the mapped region and copy data back if needed
+    auto mappedRegion =
+        std::find_if(mappedRegions.begin(), mappedRegions.end(),
+                     [pMappedPtr](const host_allocation_desc_t &desc) {
+                       return desc.ptr.get() == pMappedPtr;
+                     });
+
+    if (mappedRegion == mappedRegions.end()) {
+      UR_DFAILURE("could not find pMappedPtr:" << pMappedPtr);
+      throw UR_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (mappedRegion->flags & (UR_MAP_FLAG_WRITE | UR_MAP_FLAG_WRITE_INVALIDATE_REGION)) {
+      std::memcpy(ur_cast<char *>(ptr.get()) + mappedRegion->offset,
+                  mappedRegion->ptr.get(), mappedRegion->size);
+    }
+
+    mappedRegions.erase(mappedRegion);
+    return;
+  }
+  // No op for zero-copy path, memory is synced  
 }
 
 static v2::raii::command_list_unique_handle

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

@@ -87,6 +87,17 @@ struct ur_usm_handle_t : ur_mem_buffer_t {
   void *ptr;
 };
 
+struct host_allocation_desc_t {
+  host_allocation_desc_t(usm_unique_ptr_t ptr, size_t size, size_t offset,
+                         ur_map_flags_t flags)
+      : ptr(std::move(ptr)), size(size), offset(offset), flags(flags) {}
+
+  usm_unique_ptr_t ptr;
+  size_t size;
+  size_t offset;
+  ur_map_flags_t flags;
+};
+
 // Manages memory buffer for integrated GPU.
 // For integrated devices the buffer has been allocated in host memory
 // and can be accessed by the device without copying.
@@ -112,17 +123,7 @@ struct ur_integrated_buffer_handle_t : ur_mem_buffer_t {
 private:
   usm_unique_ptr_t ptr;
   void *writeBackPtr = nullptr;
-};
-
-struct host_allocation_desc_t {
-  host_allocation_desc_t(usm_unique_ptr_t ptr, size_t size, size_t offset,
-                         ur_map_flags_t flags)
-      : ptr(std::move(ptr)), size(size), offset(offset), flags(flags) {}
-
-  usm_unique_ptr_t ptr;
-  size_t size;
-  size_t offset;
-  ur_map_flags_t flags;
+  std::vector<host_allocation_desc_t> mappedRegions;
 };
 
 // Manages memory buffer for discrete GPU.