[DRAFT: DONT COMMIT] Enable zero-copy subbuffers across all alloc types for iGPUs

#### Details:
Description of the issue (symptom, root-cause, how it was resolved)
- Eliminates redundant weight copies during model loading for integrated GPUs by binding
  mmap'd cache file memory directly to GPU without intermediate usm_device allocation
- Reduces memory footprint during inference by reusing host memory as GPU-accessible buffers
- Zero-copy enabled when: iGPU, XE2+ architecture, USM host support available
- Falls back gracefully to copy-based path when zero-copy requirements not met

Implementation changes:
- Add ocl_engine::supports_hostbuffer() to validate zero-copy capability
  (checks for integrated GPU, XE2+ arch, USM host allocation support)
- Add ocl_engine::create_hostbuffer_impl() to bind host memory with CL_MEM_USE_HOST_PTR
- Simplify zero-copy detection in data.hpp load path (remove redundant capability checks)
- Use ib.seek_current_ptr() instead of dummy reads for padding alignment
- Remove is_mmap_tensor_4K_aligned() helpers

Changed files:
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/device_info.hpp
src/plugins/intel_gpu/src/graph/program.cpp
src/plugins/intel_gpu/src/runtime/ocl/ocl_device.cpp
src/plugins/intel_gpu/src/runtime/ocl/ocl_engine.cpp
src/plugins/intel_gpu/tests/unit/test_cases/cache_serialization_test.cpp

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

Problematic graph
NA

#### Checklist
- [x] Is it a proper fix? Yes (memory optimization, 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? NA

#### Tickets:
 - CVS-176160

#### AI Assistance:
 - AI assistance used: yes
 - AI was used for code implementation, naming suggestions, and comment refinement.

Author: Prithviraj-R

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

@@ -61,20 +61,12 @@ class BinaryOutputBuffer : public OutputBuffer<BinaryOutputBuffer> {
     size_t get_offset() const {
         return _offset;
     }
-    bool is_offset_page_aligned() const {
-        return (get_offset() % CACHE_PAGE_SIZE == 0);
+    bool is_offset_aligned(const size_t alignment) const {
+        return (get_offset() % alignment == 0);
     }
 
-    size_t get_bytes_to_page_boundary() const {
-        return CACHE_PAGE_SIZE - (get_offset() % CACHE_PAGE_SIZE);
-    }
-
-    bool is_offset_sub_buffer_aligned() const {
-        return (get_offset() % CACHE_SUB_BUFFER_ALIGNMENT == 0);
-    }
-
-    size_t get_bytes_to_sub_buffer_boundary() const {
-        return CACHE_SUB_BUFFER_ALIGNMENT - (get_offset() % CACHE_SUB_BUFFER_ALIGNMENT);
+    size_t get_bytes_to_aligned_boundary(const size_t alignment) const {
+        return alignment - (get_offset() % alignment);
     }
 
 private:
@@ -150,20 +142,11 @@ class BinaryInputBuffer : public InputBuffer<BinaryInputBuffer> {
         _stream.seekg(current_pos + static_cast<std::streampos>(size));
         _offset += size;
     }
-    bool is_offset_page_aligned() const {
-        return (get_offset() % CACHE_PAGE_SIZE == 0);
+    bool is_offset_aligned(const size_t alignment) const {
+        return (get_offset() % alignment == 0);
     }
-
-    size_t get_bytes_to_page_boundary() const {
-        return CACHE_PAGE_SIZE - (get_offset() % CACHE_PAGE_SIZE);
-    }
-
-    bool is_offset_sub_buffer_aligned() const {
-        return (get_offset() % CACHE_SUB_BUFFER_ALIGNMENT == 0);
-    }
-
-    size_t get_bytes_to_sub_buffer_boundary() const {
-        return CACHE_SUB_BUFFER_ALIGNMENT - (get_offset() % CACHE_SUB_BUFFER_ALIGNMENT);
+    size_t get_bytes_to_aligned_boundary(const size_t alignment) const {
+        return alignment - (get_offset() % alignment);
     }
     void setKernelImplParams(void* impl_params) {
         _impl_params = impl_params;

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

@@ -395,8 +395,8 @@ struct data : public primitive_base<data> {
         bool do_weightless_caching = cache_info->save(ob, data_size);
         if (!do_weightless_caching) {
             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);
+                if (!ob.is_encrypted() && !ob.is_offset_aligned(mem->get_engine()->get_device_info().cacheline_size)) {
+                    std::vector<uint8_t> pad(ob.get_bytes_to_aligned_boundary(mem->get_engine()->get_device_info().cacheline_size), 0);
                     ob << make_data(pad.data(), pad.size());
                 }
                 ob << make_data(mem->buffer_ptr(), data_size);
@@ -443,8 +443,8 @@ struct data : public primitive_base<data> {
 
         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);
+                if (!ib.is_encrypted() && !ib.is_offset_aligned(ib.get_engine().get_device_info().cacheline_size)) {
+                    std::vector<uint8_t> pad(ib.get_bytes_to_aligned_boundary(ib.get_engine().get_device_info().cacheline_size), 0);
                     ib >> make_data(pad.data(), pad.size());
                 }
                 if (enable_zero_copy_mode) {

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

@@ -145,6 +145,7 @@ struct device_info {
     uint32_t num_ccs;                           ///< Number of compute command streamers
     uint32_t sub_device_idx;                    ///< Index of sub-device
     int32_t cacheline_size;
+    uint32_t sub_buffer_base_alignment;
 
     pci_bus_info pci_info;                      ///< PCI bus information for the device
 

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

@@ -1985,9 +1985,8 @@ void program::save(cldnn::BinaryOutputBuffer& ob) const {
         ob << state_initializer.first;
         ob << state_initializer.second;
     }
-
-    if (!ob.is_encrypted() && !ob.is_offset_page_aligned()) {
-        std::vector<uint8_t> pad(ob.get_bytes_to_page_boundary(), 0);
+    if (!ob.is_encrypted() && !ob.is_offset_aligned(get_engine().get_device_info().cacheline_size)) {
+        std::vector<uint8_t> pad(ob.get_bytes_to_aligned_boundary(get_engine().get_device_info().cacheline_size), 0);
         ob << make_data(pad.data(), pad.size());
     }
 }
@@ -2215,8 +2214,8 @@ void program::load(cldnn::BinaryInputBuffer& ib,
     }
 
     // At the end of load
-    if (!ib.is_encrypted() && !ib.is_offset_page_aligned()) {
-        std::vector<uint8_t> pad(ib.get_bytes_to_page_boundary(), 0);
+    if (!ib.is_encrypted() && !ib.is_offset_aligned(get_engine().get_device_info().cacheline_size)) {
+        std::vector<uint8_t> pad(ib.get_bytes_to_aligned_boundary(get_engine().get_device_info().cacheline_size), 0);
         ib >> make_data(pad.data(), pad.size());
     }
 }

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

@@ -209,6 +209,9 @@ device_info init_device_info(const cl::Device& device, const cl::Context& contex
     info.sub_device_idx = std::numeric_limits<uint32_t>::max();
 
     info.cacheline_size = device.getInfo<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE>();
+    // Alignment requirement (in bits) for sub-buffer offsets, converting to bytes and ensuring at least 1 byte alignment.
+    auto bits = device.getInfo<CL_DEVICE_MEM_BASE_ADDR_ALIGN>();
+    info.sub_buffer_base_alignment = std::max<uint32_t>(1, bits / 8);
     info.execution_units_count = device.getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>();
 
     info.gpu_frequency = static_cast<uint32_t>(device.getInfo<CL_DEVICE_MAX_CLOCK_FREQUENCY>());

src/plugins/intel_gpu/tests/unit/test_cases/cache_serialization_test.cpp

@@ -330,8 +330,8 @@ membuf make_oversized_data_blob(const layout& output_layout, size_t malicious_da
     ob << weightless_caching;
 
     // Mirror the reader's alignment padding so stream offsets stay in sync.
-    if (!ob.is_encrypted() && !ob.is_offset_sub_buffer_aligned()) {
-        std::vector<uint8_t> pad(ob.get_bytes_to_sub_buffer_boundary(), 0);
+    if (!ob.is_encrypted() && !ob.is_offset_aligned(128)) {
+        std::vector<uint8_t> pad(ob.get_bytes_to_aligned_boundary(128), 0);
         ob << make_data(pad.data(), pad.size());
     }