PrefetchVirtualMemory does not prefetch virtual memory (windows api bug)

[no-j]

Windows Build Number

10.0.19044.0

Processor Architecture

AMD64

Memory

16GB

Storage Type, free / capacity

SSD 512GB

Relevant apps installed

Windows

Traces collected via Feedback Hub

N/A

Isssue description

I tested PrefetchVirtualMemory to minimize page faults when creating a file mapping, and measured the performance (compiler ticks using __rdtsc() intrinsic) and the actual count of page faults (using GetProcessMemoryInfo) when processing files, with and without a call to PrefetchVirtualMemory.

To my surprise, PrefetchVirtualMemory does not work as advertise and does not do it's only job, which was to actually fetch the memory from disk as efficiently as possible to minimize page faults.

I used the following process for testing, loading a range of file sizes (I'll share my results for a ~500MB file):
I opened a file handle, created a memory map and a view of the whole file, then I processed the whole file making sure to touch every page of the allocated view.
Then I repeated the process, and called PrefetchVirtualMemory on the view before processing the file.
I got the exact same page fault count overall in both cases, and to add insult to injury, the performance was slightly worse with PrefetchVirtualMemory, making the whole thing useless as it is its only job.

Steps to reproduce

Running the following code on windows:

#include <psapi.h> // for GetProcessMemoryInfo

char process_file(const char *file_name, bool use_prefetch_virtual_memory) {
    HANDLE file_handle;
    file_handle = CreateFileA(file_name, GENERIC_READ, FILE_SHARE_READ,
                              0, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, 0);
    
    if(file_handle == INVALID_HANDLE_VALUE) {
        fprintf(stderr, "Could not open the file '%s'\n", file_name);
        return 0;
    }
    
    LARGE_INTEGER file_size;
    if(!GetFileSizeEx(file_handle, &file_size)) {
        CloseHandle(file_handle);
        fprintf(stderr, "Could not open the file '%s'\n", file_name);
        return 0;
    }
    
    size_t size = file_size.QuadPart;
    
    HANDLE mapping_handle = CreateFileMapping(file_handle, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
    
    const char *view = (const char *)MapViewOfFile(mapping_handle, FILE_MAP_READ, 0, 0, 0);
    
    PROCESS_MEMORY_COUNTERS counter0, counter1, counter2;
    GetProcessMemoryInfo(GetCurrentProcess(), &counter0, sizeof(counter0));
    
    WIN32_MEMORY_RANGE_ENTRY memory_range_entry[] = {(void *)view, size};
    if(use_prefetch_virtual_memory) PrefetchVirtualMemory(GetCurrentProcess(), 1, memory_range_entry, 0);
    
    GetProcessMemoryInfo(GetCurrentProcess(), &counter1, sizeof(counter1));
    
    char result = 0; // I'm using "result" here only so that the optimizer won't skip this loop
    for(int i = 0; i < size; ++i) {
        result += view[i];
    }
    
    GetProcessMemoryInfo(GetCurrentProcess(), &counter2, sizeof(counter2));
    
    DWORD prefetch_fault_count = counter1.PageFaultCount - counter0.PageFaultCount;
    DWORD manual_fault_count   = counter2.PageFaultCount - counter1.PageFaultCount;

    printf("Using PrefetchVirtualMemory: %s\n", use_prefetch_virtual_memory ? "yes" : "no");

    printf("Page faults (during prefetch):        %d\n", prefetch_fault_count);
    printf("Page faults (during file processing): %d\n", manual_fault_count);
    printf("Page faults (overall):                %d\n", prefetch_fault_count + manual_fault_count);
    
    UnmapViewOfFile(view);
    CloseHandle(mapping_handle);
    CloseHandle(file_handle);
    
    return result;
}

Expected Behavior

Using PrefetchVirtualMemory: no
Page faults (during prefetch):        0
Page faults (during file processing): 161027
Page faults (overall):                161027

Using PrefetchVirtualMemory: yes
Page faults (during prefetch):        314
Page faults (during file processing): **MUCH LOWER** than 160713
Page faults (overall):                **MUCH LOWER** than 161027

Actual Behavior

Using PrefetchVirtualMemory: no
Page faults (during prefetch):        0
Page faults (during file processing): 161027
Page faults (overall):                161027

Using PrefetchVirtualMemory: yes
Page faults (during prefetch):        314
Page faults (during file processing): 160713
Page faults (overall):                161027

[AlexeiScherbakov]

I'm also wondering how exactly to use this API function and what it actually does

We need to find a way to load the file into memory as quickly as possible

[ihewro]

The data PROCESS_MEMORY_COUNTERS from GetProcessMemoryInfo() can't get hard page fault count, maybe we could use SystemProcessInformation to get HardFaultCount in SYSTEM_PROCESS_INFORMATION_EX

Here the code from chromium components\startup_metric_utils\browser\startup_metric_utils.cc

// // The following structures are derived from online documentation and are not
// // defined in any official Windows header.
// struct SYSTEM_PROCESS_INFORMATION_EX {
//   ULONG NextEntryOffset;
//   ULONG NumberOfThreads;
//   LARGE_INTEGER WorkingSetPrivateSize;
//   ULONG HardFaultCount;
//   BYTE Reserved1[36];
//   PVOID Reserved2[3];
//   // This is labeled a handle so that it expands to the correct size for
//   // 32-bit and 64-bit operating systems. However, under the hood it's a
//   // 32-bit DWORD containing the process ID.
//   HANDLE UniqueProcessId;
//   PVOID Reserved3;
//   ULONG HandleCount;
//   BYTE Reserved4[4];
//   PVOID Reserved5[11];
//   SIZE_T PeakPagefileUsage;
//   SIZE_T PrivatePageCount;
//   LARGE_INTEGER Reserved6[6];
//   // Array of SYSTEM_THREAD_INFORMATION structs follows.
// };

// From ntddk.h
 struct VM_COUNTERS {
  SIZE_T PeakVirtualSize;
  SIZE_T VirtualSize;
  ULONG PageFaultCount;
  // Padding here in 64-bit
  SIZE_T PeakWorkingSetSize;
  SIZE_T WorkingSetSize;
  SIZE_T QuotaPeakPagedPoolUsage;
  SIZE_T QuotaPagedPoolUsage;
  SIZE_T QuotaPeakNonPagedPoolUsage;
  SIZE_T QuotaNonPagedPoolUsage;
  SIZE_T PagefileUsage;
  SIZE_T PeakPagefileUsage;
};

struct SYSTEM_PROCESS_INFORMATION {
  ULONG NextEntryOffset;
  ULONG NumberOfThreads;
  // http://processhacker.sourceforge.net/doc/struct___s_y_s_t_e_m___p_r_o_c_e_s_s___i_n_f_o_r_m_a_t_i_o_n.html
  ULONGLONG WorkingSetPrivateSize;
  ULONG HardFaultCount;
  ULONG Reserved1;
  ULONGLONG CycleTime;
  ULONGLONG CreateTime;
  ULONGLONG UserTime;
  ULONGLONG KernelTime;
  UNICODE_STRING ImageName;
  KPRIORITY BasePriority;
  HANDLE ProcessId;
  HANDLE ParentProcessId;
  ULONG HandleCount;
  ULONG Reserved2[2];
  // Padding here in 64-bit
  VM_COUNTERS VirtualMemoryCounters;
  size_t Reserved3;
  IO_COUNTERS IoCounters;
  SYSTEM_THREAD_INFORMATION Threads[1];
};


// The signature of the NtQuerySystemInformation function.
typedef NTSTATUS(WINAPI* NtQuerySystemInformationPtr)(SYSTEM_INFORMATION_CLASS,
                                                      PVOID,
                                                      ULONG,
                                                      PULONG);

/**
 * @brief Gets the number of hard page faults for the current process.
 *
 * This function uses the native Windows API NtQuerySystemInformation to retrieve
 * detailed process information, including the hard fault count. It is more
 * accurate for this specific metric than GetProcessMemoryInfo.
 * @return The number of hard page faults, or 0 on failure.
 */
size_t GetHardPageFaults() {
  // Get the function pointer.
  static const NtQuerySystemInformationPtr query_sys_info =
      reinterpret_cast<NtQuerySystemInformationPtr>(::GetProcAddress(
          GetModuleHandle(L"ntdll.dll"), "NtQuerySystemInformation"));
  if (query_sys_info == nullptr) {
    return 0;
  }

  // The output of this system call depends on the number of threads and
  // processes on the entire system, and this can change between calls. Retry
  // a small handful of times growing the buffer along the way.
  std::vector<uint8_t> buffer(32 * 1024);
  constexpr int kMaxNumBufferResize = 2;
  int num_buffer_resize = 0;
  for (;;) {
    ULONG return_length = 0;
    const NTSTATUS status =
        query_sys_info(SystemProcessInformation, buffer.data(),
                       static_cast<ULONG>(buffer.size()), &return_length);

    if (NT_SUCCESS(status)) {
      break;
    }

    if (return_length > buffer.size()) {
      constexpr ULONG kMaxLength = 10 * 1024 * 1024;
      if (return_length >= kMaxLength) {
        return 0;
      }

      if (num_buffer_resize < kMaxNumBufferResize) {
        ++num_buffer_resize;
        buffer.resize(return_length);
        continue;
      }
    }
    return 0;
  }

  // Look for the struct housing information for the current process.
  const DWORD proc_id = ::GetCurrentProcessId();
  size_t index = 0;
  while (index < buffer.size()) {
    SYSTEM_PROCESS_INFORMATION* proc_info =
        reinterpret_cast<SYSTEM_PROCESS_INFORMATION*>(buffer.data() + index);

    auto pid = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(proc_info->ProcessId));
    // std::cout << "pid:" << pid  << ",page_faults:" << proc_info->HardFaultCount << std::endl;
    if (pid  == proc_id) {
      std::cout << "HardFaultCount:" << proc_info->HardFaultCount << ",pid:" << proc_id << std::endl;
      return proc_info->HardFaultCount;
    }
    if (proc_info->NextEntryOffset <= 0) {
      return 0;
    }
    index += proc_info->NextEntryOffset;
  }

  std::cout << "Failed to find process info for PID " << proc_id << std::endl;


  return 0;
}

[FaultyPine]

Upon measuring hard page faults with the above method and adding a short sleep before touching the mapped sections (to ensure enough time for prefetch), I'm seeing expected results, where PrefetchVirtualMemory reduces the number of hard faults to 0.
Note: even without the sleep, it's still reducing the faults to 0.