[Core] Add parallel mapping population on Windows (#36586)

### Details:
 - Implement `ov::MappedMemory::hint_prefetch` for Windows os
- Add forward-declared `populate_pages()` to extract common code and to
avoid adding it as util tool for now.
- Tests for `hint_prefetch()` are located in
_src\core\tests\mmap_object.cpp_. Test for util::vm_prefetch was added
to _memory_test.cpp_
- Add previously requested changes to _file_load_benchmark.cpp_ and more
specific names for test columns:
 
 Size (MiB) | parallel loop sync |  default mmap |      ifstream
-----------|--------------------|---------------|--------------
x         |               x |          x |        x
 

Size (MiB) | parallel loop sync |    loop touch
-----------|--------------------|--------------
x         |              x  |          x

### Tickets:
 - [CVS-186579](https://jira.devtools.intel.com/browse/CVS-186579)

### AI Assistance:
- *AI assistance used: yes: codebase analysis, brainstorming, fixing
issues*

---------

Co-authored-by: Pawel Raasz <pawel.raasz@intel.com>

Author: almilosz

src/common/util/CMakeLists.txt

@@ -69,6 +69,7 @@ target_sources(${TARGET_NAME}
         ${CMAKE_CURRENT_SOURCE_DIR}/src/file_path.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/file_util.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/log.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/memory.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/native_stream.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/native_streambuf.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/parallel_read_streambuf.cpp

src/common/util/include/openvino/util/memory.hpp

@@ -12,6 +12,9 @@
 
 namespace ov::util {
 
+/** @brief One mebibyte (1024 * 1024 bytes). */
+inline constexpr size_t one_mib = 1024 * 1024;
+
 /** @brief Minimum guaranteed page alignment on all supported platforms (x86, ARM, RISC-V). */
 inline constexpr size_t min_page_alignment = 4096;
 

src/common/util/src/memory.cpp

@@ -0,0 +1,57 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/util/memory.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <thread>
+#include <vector>
+
+#include "openvino/util/common_util.hpp"
+#include "openvino/util/mmap_object.hpp"
+
+namespace ov::util {
+void populate_pages(void* ptr, size_t size, size_t num_threads) noexcept;
+
+namespace {
+
+/**
+ * @brief Functor that touches one byte per page over [m_begin, m_end) to force the pages resident.
+ *
+ * The volatile accumulator prevents the compiler from optimizing the read loop away.
+ */
+struct PageToucher {
+    const uint8_t* m_begin;
+    const uint8_t* m_end;
+    const size_t m_page_size;
+
+    void operator()() const noexcept {
+        volatile uint8_t local = 0;  // prevents the compiler from optimizing the loop away
+        for (auto begin = m_begin; begin < m_end; begin += m_page_size) {
+            local += *begin;
+        }
+    }
+};
+
+}  // namespace
+
+void populate_pages(void* ptr, size_t size, size_t num_threads) noexcept {
+    // ptr and size are guaranteed page-aligned by vm_prefetch's precondition.
+    const auto page_size = static_cast<size_t>(get_system_page_size());
+    const auto chunk_size = std::max<size_t>(align_size_up(size / num_threads, page_size), one_mib);
+
+    std::vector<std::thread> threads;
+    threads.reserve(ceil_div(size, chunk_size));
+
+    for (auto first = reinterpret_cast<const uint8_t*>(ptr), last = first + size; first < last; first += chunk_size) {
+        threads.emplace_back(PageToucher{first, std::min(first + chunk_size, last), page_size});
+    }
+    for (auto& t : threads) {
+        t.join();
+    }
+}
+
+}  // namespace ov::util

src/common/util/src/os/lin/lin_memory.cpp

@@ -4,20 +4,14 @@
 
 #include <sys/mman.h>
 
-#include <algorithm>
 #include <cassert>
 #include <cerrno>
 #include <cstddef>
-#include <cstdint>
 #include <cstdlib>
 #include <cstring>
-#include <thread>
 #include <tuple>
-#include <vector>
 
-#include "openvino/util/common_util.hpp"
 #include "openvino/util/memory.hpp"
-#include "openvino/util/mmap_object.hpp"
 
 namespace ov::util {
 
@@ -28,37 +22,10 @@ void madvise_hint(void* ptr, size_t size) noexcept {
     madvise(ptr, size, MADV_WILLNEED);
 }
 
-struct PageToucher {
-    const uint8_t* m_begin;
-    const uint8_t* m_end;
-    const size_t m_page_size;
-
-    void operator()() const noexcept {
-        volatile uint8_t local = 0;  // prevents the compiler from optimizing the loop away
-        for (auto begin = m_begin; begin < m_end; begin += m_page_size) {
-            local += *begin;
-        }
-    }
-};
-
-void populate_pages(void* ptr, size_t size, size_t num_threads) noexcept {
-    // ptr and size are guaranteed page-aligned by vm_prefetch's precondition.
-    const auto page_size = static_cast<size_t>(get_system_page_size());
-    const auto chunk_size = std::max<size_t>(align_size_up(size / num_threads, page_size), 1024 * 1024);
-
-    std::vector<std::thread> threads;
-    threads.reserve(ceil_div(size, chunk_size));
-
-    for (auto first = reinterpret_cast<const uint8_t*>(ptr), last = first + size; first < last; first += chunk_size) {
-        threads.emplace_back(PageToucher{first, std::min(first + chunk_size, last), page_size});
-    }
-    for (auto& t : threads) {
-        t.join();
-    }
-}
-
 }  // namespace
 
+void populate_pages(void* ptr, size_t size, size_t num_threads) noexcept;
+
 void* aligned_alloc(size_t size, size_t alignment) noexcept {
     if (alignment == 0) {
         alignment = alignof(std::max_align_t);
@@ -109,13 +76,10 @@ void vm_release(void* ptr, size_t size) noexcept {
 
 void vm_prefetch(void* ptr, size_t size, size_t num_threads) noexcept {
     assert(ptr != nullptr && size > 0);
-    // assert if region is not mmap-backed.
-
     if (num_threads == 0) {
-        // Option 1: OS advisory hints — async, low overhead.
         madvise_hint(ptr, size);
     } else {
-        // Option 2: parallel synchronous touch — blocks until every page is resident.
+        // blocks until every page has been faulted in.
         populate_pages(ptr, size, num_threads);
     }
 }

src/common/util/src/os/win/win_memory.cpp

@@ -18,6 +18,8 @@
 
 namespace ov::util {
 
+void populate_pages(void* ptr, size_t size, size_t num_threads) noexcept;
+
 void* aligned_alloc(size_t size, size_t alignment) noexcept {
     if (alignment == 0) {
         alignment = alignof(std::max_align_t);
@@ -59,13 +61,12 @@ void vm_release(void* ptr, size_t) noexcept {
 
 void vm_prefetch(void* ptr, size_t size, size_t num_threads) noexcept {
     assert(ptr != nullptr && size > 0);
-    // CVS-186579
-    // assert if region is not mmap-baked.
-
     if (num_threads == 0) {
-        // Option 1: OS advisory hints
+        WIN32_MEMORY_RANGE_ENTRY entry{ptr, size};
+        ::PrefetchVirtualMemory(::GetCurrentProcess(), 1, &entry, 0);
     } else {
-        // Option 2: parallel synchronous prefault & touch
+        // blocks until every page has been faulted in.
+        populate_pages(ptr, size, num_threads);
     }
 }
 

src/common/util/src/os/win/win_mmap_object.cpp

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <shared_mutex>
 #include <stdexcept>
+#include <thread>
 #include <vector>
 
 #include "openvino/util/common_util.hpp"
@@ -302,7 +303,7 @@ class MapHolder : public ov::MappedMemory {
 
     void hint_evict(size_t offset, size_t size) noexcept override;
 
-    void hint_prefetch(size_t /*offset*/, size_t /*size*/) override {}
+    void hint_prefetch(size_t offset, size_t size) override;
 
 private:
     /**
@@ -743,6 +744,33 @@ bool MapHolder::try_remap_slot(uintptr_t fault_addr) {
     return remap_placeholder(proc, placeholder_base, placeholder_size);
 }
 
+namespace {
+
+// Clamps [offset, offset + size) to [0, mapping_size) and page-aligns the result.
+// Returns an empty region (m_length == 0) for a null/empty mapping, an offset at or past the end,
+// or a sub-page request.
+util::AlignedRegion clamp_align_region(const void* data, size_t mapping_size, size_t offset, size_t size) noexcept {
+    const auto page_size = static_cast<size_t>(util::get_system_page_size());
+    if (data == nullptr || mapping_size == 0 || offset >= mapping_size || size < page_size) {
+        return {};
+    }
+    const auto available = mapping_size - offset;
+    const auto raw_len = (size == auto_size) ? available : std::min(size, available);
+    return util::align_region(reinterpret_cast<uintptr_t>(data) + offset, raw_len, page_size);
+}
+
+}  // namespace
+
+void MapHolder::hint_prefetch(size_t offset, size_t size) {
+    // Below 4 MiB the overhead of spawning threads exceeds the benefit; skip.
+    if (const auto region = clamp_align_region(m_data, m_size, offset, size); region.m_length > 4 * util::one_mib) {
+        const auto num_threads = std::min<size_t>(10, std::thread::hardware_concurrency());
+        const auto aligned_size =
+            util::align_size_up(region.m_length, static_cast<size_t>(util::get_system_page_size()));
+        util::vm_prefetch(reinterpret_cast<void*>(region.m_address), aligned_size, num_threads);
+    }
+}
+
 std::pair<char*, char*> MapHolder::compute_evict_range(size_t offset, size_t size) const noexcept {
     // Require placeholder path, API availability, and a live VEH (eviction without VEH
     // would leave inaccessible placeholders on the next access).