[GPU] Enable zero-copy host-backed buffers for Xe2+ iGPUs

#### Details:
Description of the issue(symptom, root-cause, how it was resolved)
- Add engine::can_bind_host_buffer() to validate iGPU, Xe2+, USM host support, and page alignment
- Add engine::bind_host_owned_buffer() to wrap host memory for GPU access without copies
- Use seek instead of read for padding in data.hpp load path
- Remove obsolete helper methods from binary_buffer.hpp

The code and line that caused this issue (if it is not changed directly)
src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp
src/plugins/intel_gpu/include/intel_gpu/runtime/engine.hpp
src/plugins/intel_gpu/src/graph/program.cpp
src/plugins/intel_gpu/src/runtime/engine.cpp
src/plugins/intel_gpu/src/runtime/ocl/ocl_engine.cpp
src/plugins/intel_gpu/src/runtime/ocl/ocl_engine.hpp
src/plugins/intel_gpu/src/runtime/sycl/sycl_engine.cpp
src/plugins/intel_gpu/src/runtime/sycl/sycl_engine.hpp
src/plugins/intel_gpu/src/runtime/ze/ze_engine.cpp
src/plugins/intel_gpu/src/runtime/ze/ze_engine.hpp

Reproduction step and snapshot (if applicable. Do not attach for customer model) NA

Problematic graph
NA

#### Checklist
- [x] Is it a proper fix? Yes (not a workaround)
- [x] Did you include test case for this fix, if necessary? NA
- [x] Did you review existing test that can be extended to cover this scenario? Which test did you review? NA

#### Tickets:
 - CVS-177982

#### AI Assistance:
 - AI assistance used: yes
 - AI was used for code refactoring, API naming, and file editing automation. All changes were manually validated through code review and verification of implementation correctness.

Author: Prithviraj-R

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp

@@ -117,13 +117,6 @@ class BinaryInputBuffer : public InputBuffer<BinaryInputBuffer> {
     std::streambuf* get_streambuf() const {
         return _stream.rdbuf();
     }
-    bool has_mmap_tensor() const {
-        return _tensor_base_ptr != nullptr;
-    }
-
-    bool is_mmap_tensor_4K_aligned() const {
-        return has_mmap_tensor() && (reinterpret_cast<std::uintptr_t>(_tensor_base_ptr) % CACHE_PAGE_SIZE == 0);
-    }
 
     const size_t* get_mmap_tensor() const {
         return _tensor_base_ptr;

src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp

@@ -385,11 +385,11 @@ struct data : public primitive_base<data> {
 
         bool do_weightless_caching = cache_info->save(ob, data_size);
         if (!do_weightless_caching) {
+            if (!ob.is_encrypted() && !ob.is_offset_sub_buffer_aligned()) {
+                std::vector<uint8_t> pad(ob.get_bytes_to_sub_buffer_boundary(), 0);
+                ob << make_data(pad.data(), pad.size());
+            }
             if (is_alloc_host_accessible(_allocation_type)) {
-                if (!ob.is_encrypted() && !ob.is_offset_sub_buffer_aligned()) {
-                    std::vector<uint8_t> pad(ob.get_bytes_to_sub_buffer_boundary(), 0);
-                    ob << make_data(pad.data(), pad.size());
-                }
                 ob << make_data(mem->buffer_ptr(), data_size);
             } else {
                 std::vector<uint8_t> _buf;
@@ -417,29 +417,24 @@ struct data : public primitive_base<data> {
 
         bool weightless_caching = false;
         ib >> weightless_caching;
-
-        bool enable_zero_copy_mode = ib.is_mmap_tensor_4K_aligned() && ib.get_engine().get_device_info().arch >= gpu_arch::xe2 &&
-                                     ib.get_engine().get_device_info().dev_type == device_type::integrated_gpu &&
-                                     _allocation_type == allocation_type::usm_host && !weightless_caching &&
-                                     model_tensor_base != nullptr;
-        if (!enable_zero_copy_mode) {
+        bool zero_copy_mode = !weightless_caching && ib.get_engine().can_bind_host_buffer(ib.get_mmap_tensor());
+        if (!zero_copy_mode) {
             mem = ib.get_engine().allocate_memory(output_layout, _allocation_type, false);
         }
-        
+
         bool is_weightless_caching = cache_info->load(ib, mem, weights_memory, weightless_caching);
 
         if (!is_weightless_caching) {
-            if (is_alloc_host_accessible(_allocation_type)) {
-                if (!ib.is_encrypted() && !ib.is_offset_sub_buffer_aligned()) {
-                    std::vector<uint8_t> pad(ib.get_bytes_to_sub_buffer_boundary(), 0);
-                    ib >> make_data(pad.data(), pad.size());
-                }
-                if (enable_zero_copy_mode) {
-                    mem = ib.get_engine().create_subbuffer(*model_tensor_base, output_layout, ib.get_offset());
-                    ib.seek_current_ptr(data_size);
-                } else {
-                    ib >> make_data(std::move(mem->buffer_ptr()), data_size);
-                }
+            // Skip padding bytes (page alignment required for binding host-owned buffers)
+            if (!ib.is_encrypted() && !ib.is_offset_sub_buffer_aligned()) {
+                ib.seek_current_ptr(ib.get_bytes_to_sub_buffer_boundary());
+            }
+            // Zero-copy: create subbuffer referencing mmap'd cache without host-to-device transfer
+            if (zero_copy_mode) {
+                mem = ib.get_engine().create_subbuffer(*model_tensor_base, output_layout, ib.get_offset());
+                ib.seek_current_ptr(data_size);
+            } else if (is_alloc_host_accessible(_allocation_type)) {
+                ib >> make_data(std::move(mem->buffer_ptr()), data_size);
             } else {
                 const size_t DATA_BLOCK_SIZE = 4 * 1024 * 1024;
                 auto& eng = ib.get_engine();

src/plugins/intel_gpu/include/intel_gpu/runtime/engine.hpp

@@ -64,8 +64,11 @@ class engine {
     /// Created subbuffer memory object from the other @p memory and reinterpred the data using specified @p new_layout
     virtual memory_ptr create_subbuffer(const memory& memory, const layout& new_layout, size_t byte_offset) = 0;
 
-    /// Created memory object by wrapping a host-allocated, memory-mapped layout region
-    virtual memory_ptr create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) = 0;
+    /// Check if host-owned buffer can be bound for GPU access (integrated GPU, Xe2+, page-aligned)
+    bool can_bind_host_buffer(const void* host_address) const;
+
+    /// Bind host-owned buffer for zero-copy GPU access (returns nullptr if binding not supported)
+    virtual memory_ptr bind_host_owned_buffer(const void* host_address, size_t data_size) = 0;
 
     /// Created memory object from the other @p memory and reinterpred the data using specified @p new_layout
     virtual memory_ptr reinterpret_buffer(const memory& memory, const layout& new_layout) = 0;

src/plugins/intel_gpu/src/graph/program.cpp

@@ -2001,15 +2001,9 @@ void program::load(cldnn::BinaryInputBuffer& ib,
         }
     }
 
-    const bool can_use_mmap_zero_copy = ib.is_mmap_tensor_4K_aligned() && _engine.get_device_info().arch >= gpu_arch::xe2 &&
-                                        _engine.get_device_info().dev_type == device_type::integrated_gpu && !_config.get_enable_weightless();
     memory_ptr model_tensor_base_ptr = nullptr;
-    if (can_use_mmap_zero_copy) {
-        model_tensor_base_ptr =
-            ib.get_engine().create_mmap_hostbuffer(ib.get_mmap_tensor(),
-                                                   ib.get_stream_size(),
-                                                   allocation_type::usm_host,
-                                                   layout({{static_cast<tensor::value_type>(ib.get_stream_size()), 1, 1, 1}, data_types::u8, format::bfyx}));
+    if (!_config.get_enable_weightless()) {
+        model_tensor_base_ptr = ib.get_engine().bind_host_owned_buffer(ib.get_mmap_tensor(), ib.get_stream_size());
     }
 
     size_t num_nodes;
@@ -2198,10 +2192,9 @@ void program::load(cldnn::BinaryInputBuffer& ib,
         state_initializers[variable_id] = initializers;
     }
 
-    // At the end of load
+    // Skip padding bytes (page alignment required for binding host-owned buffers)
     if (!ib.is_encrypted() && !ib.is_offset_page_aligned()) {
-        std::vector<uint8_t> pad(ib.get_bytes_to_page_boundary(), 0);
-        ib >> make_data(pad.data(), pad.size());
+        ib.seek_current_ptr(ib.get_bytes_to_page_boundary());
     }
 }
 

src/plugins/intel_gpu/src/runtime/engine.cpp

@@ -8,6 +8,7 @@
 #include "intel_gpu/runtime/stream.hpp"
 #include "intel_gpu/runtime/device_query.hpp"
 #include "intel_gpu/runtime/debug_configuration.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 
 #include "ocl/ocl_engine_factory.hpp"
 #include "ze/ze_engine_factory.hpp"
@@ -97,6 +98,30 @@ uint64_t engine::get_host_memory_size() const {
     return static_cast<uint64_t>(get_cpu_ram_size());
 }
 
+bool engine::can_bind_host_buffer(const void* host_address) const {
+    const auto& info = get_device_info();
+
+    // Check hardware capabilities
+    if (info.dev_type != device_type::integrated_gpu)
+        return false;
+
+    if (info.arch < gpu_arch::xe2)
+        return false;
+
+    if (!supports_allocation(allocation_type::usm_host))
+        return false;
+
+    // Buffer address must be provided and page-aligned
+    if (host_address == nullptr)
+        return false;
+
+    const auto address = reinterpret_cast<std::uintptr_t>(host_address);
+    if (address % CACHE_PAGE_SIZE != 0)
+        return false;
+
+    return true;
+}
+
 bool engine::supports_allocation(allocation_type type) const {
     if (memory_capabilities::is_usm_type(type) && !use_unified_shared_memory())
         return false;

src/plugins/intel_gpu/src/runtime/ocl/ocl_engine.cpp

@@ -238,23 +238,29 @@ memory::ptr ocl_engine::create_subbuffer(const memory& memory, const layout& new
     }
 }
 
-memory_ptr ocl_engine::create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) {
+memory_ptr ocl_engine::bind_host_owned_buffer(const void* host_address, size_t data_size) {
+    // Validate that host-backed memory is supported for this buffer
+    if (!can_bind_host_buffer(host_address)) {
+        return nullptr;  // Validation failed - return nullptr for graceful fallback
+    }
+
+    // All validation passed - create the host-backed buffer
+    constexpr allocation_type type = allocation_type::usm_host;
+    layout buffer_layout({{static_cast<tensor::value_type>(data_size), 1, 1, 1}, data_types::u8, format::bfyx});
+
     auto tracker = std::make_shared<MemoryTracker>(this,
-                                                   const_cast<void*>(mmapped_address),  // Point directly to mmap'd memory
+                                                   const_cast<void*>(host_address),
                                                    data_size,
-                                                   _allocation_type);
-    std::uintptr_t mmap_address = reinterpret_cast<std::uintptr_t>(mmapped_address);
-    std::uintptr_t aligned_addr = mmap_address & ~(static_cast<std::uintptr_t>(cldnn::CACHE_PAGE_SIZE) - 1);
-    void* mmap_aligned_address = reinterpret_cast<void*>(aligned_addr);
+                                                   type);
 
     cl_int err = CL_SUCCESS;
     cl_mem_flags flags = CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR;
 #ifdef CL_MEM_FORCE_HOST_MEMORY_INTEL
     flags |= CL_MEM_FORCE_HOST_MEMORY_INTEL;
 #endif
-    cl::Buffer buffer(get_cl_context(), flags, data_size, mmap_aligned_address, &err);
-    OPENVINO_ASSERT(err == CL_SUCCESS, "clcreatebuffer with CL_MEM_USE_HOST_PTR and CL_MEM_FORCE_HOST_MEMORY_INTEL failed!");
-    return std::make_shared<ocl::gpu_buffer>(this, output_layout, buffer, tracker);
+    cl::Buffer buffer(get_cl_context(), flags, data_size, const_cast<void*>(host_address), &err);
+    OPENVINO_ASSERT(err == CL_SUCCESS, "[GPU] Failed to create host-backed buffer with CL_MEM_USE_HOST_PTR and CL_MEM_FORCE_HOST_MEMORY_INTEL");
+    return std::make_shared<ocl::gpu_buffer>(this, buffer_layout, buffer, tracker);
 }
 
 memory::ptr ocl_engine::reinterpret_buffer(const memory& memory, const layout& new_layout) {

src/plugins/intel_gpu/src/runtime/ocl/ocl_engine.hpp

@@ -26,7 +26,7 @@ class ocl_engine : public engine {
     memory_ptr allocate_memory(const layout& layout, allocation_type type, bool reset = true) override;
     memory_ptr reinterpret_handle(const layout& new_layout, shared_mem_params params) override;
     memory_ptr create_subbuffer(const memory& memory, const layout& new_layout, size_t offset) override;
-    memory_ptr create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) override;
+    memory_ptr bind_host_owned_buffer(const void* host_address, size_t data_size) override;
     memory_ptr reinterpret_buffer(const memory& memory, const layout& new_layout) override;
     memory_ptr import_buffer(const layout&, ov::intel_gpu::os_handle_param external_handle) override;
     bool is_the_same_buffer(const memory& mem1, const memory& mem2) override;

src/plugins/intel_gpu/src/runtime/sycl/sycl_engine.cpp

@@ -151,7 +151,7 @@ memory::ptr sycl_engine::create_subbuffer(const memory& memory, const layout& ne
     }
 }
 
-memory_ptr sycl_engine::create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) {
+memory_ptr sycl_engine::bind_host_owned_buffer(const void* host_address, size_t data_size) {
     OPENVINO_NOT_IMPLEMENTED;
 }
 

src/plugins/intel_gpu/src/runtime/sycl/sycl_engine.hpp

@@ -30,7 +30,7 @@ class sycl_engine : public engine {
     memory_ptr allocate_memory(const layout& layout, allocation_type type, bool reset = true) override;
     memory_ptr reinterpret_handle(const layout& new_layout, shared_mem_params params) override;
     memory_ptr create_subbuffer(const memory& memory, const layout& new_layout, size_t offset) override;
-    memory_ptr create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) override;
+    memory_ptr bind_host_owned_buffer(const void* host_address, size_t data_size) override;
     memory_ptr reinterpret_buffer(const memory& memory, const layout& new_layout) override;
     memory_ptr import_buffer(const layout& layout, ov::intel_gpu::os_handle_param external_handle) override;
     bool is_the_same_buffer(const memory& mem1, const memory& mem2) override;

src/plugins/intel_gpu/src/runtime/ze/ze_engine.cpp

@@ -171,7 +171,7 @@ memory_ptr ze_engine::create_subbuffer(const memory& memory, const layout& new_l
                              memory.get_mem_tracker());
 }
 
-memory_ptr ze_engine::create_mmap_hostbuffer(const void* mmapped_address, size_t data_size, allocation_type _allocation_type, const layout output_layout) {
+memory_ptr ze_engine::bind_host_owned_buffer(const void* host_address, size_t data_size) {
     OPENVINO_NOT_IMPLEMENTED;
 }