CUDA Unified Memory: Difference in behaviour on Windows and Linux - c++

Question

I am porting an application from Linux to Windows and discovered significant runtime differences of the same code on the same hardware between Windows and Linux.
A minimal working example:
#include <iostream>
#include <chrono>
#include <cuda.h>
constexpr unsigned int MB = 1000000;
constexpr unsigned int num_bytes = 20 * MB;
constexpr unsigned int repeats = 50;
constexpr unsigned int the_answer = 42;
constexpr unsigned int half_of_the_answer = the_answer / 2;
constexpr unsigned int array_index = 100;
__global__ void kernel(uint8_t* data){
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i<num_bytes){
data[i] = half_of_the_answer;
}
}
void doSomethingOnGPU(uint8_t* data){
cudaStream_t stream;
cudaStreamCreate(&stream);
cudaStreamAttachMemAsync(stream, data, 0, cudaMemAttachSingle);
kernel<<<num_bytes/1000, 1000, 0, stream>>>(data);
cudaStreamSynchronize(stream);
cudaStreamDestroy(stream);
cudaDeviceSynchronize();
}
void doSomethingOnCPU(uint8_t* pic_unpacked){
for(unsigned int i=0; i < num_bytes; i++){
pic_unpacked[i] = the_answer;
}
}
int main() {
uint8_t* data{};
cudaMallocManaged(&data, num_bytes, cudaMemAttachHost);
for(unsigned int i=0;i<repeats;i++){
auto start_time_cpu = std::chrono::high_resolution_clock::now();
doSomethingOnCPU(data);
auto stop_time_cpu = std::chrono::high_resolution_clock::now();
auto duration_cpu = std::chrono::duration_cast<std::chrono::milliseconds>(stop_time_cpu-start_time_cpu);
std::cout << "CPU computation took "<< duration_cpu.count() << "ms, data[" << array_index << "]="
<< static_cast<unsigned int>(data[array_index]) << std::endl;
auto start_time_gpu = std::chrono::high_resolution_clock::now();
doSomethingOnGPU(data);
auto stop_time_gpu = std::chrono::high_resolution_clock::now();
auto duration_gpu = std::chrono::duration_cast<std::chrono::milliseconds>(stop_time_gpu-start_time_gpu);
std::cout << "GPU computation took "<< duration_gpu.count() << "ms, data[" << array_index << "]="
<< static_cast<unsigned int>(data[array_index]) << std::endl << std::endl;
}
cudaFree(data);
return 0;
}
This leads to the following output on Windows:
CPU computation took 216ms, data[100]=42
GPU computation took 29ms, data[100]=21
and to the following output on Linux:
CPU computation took 20ms, data[100]=42
GPU computation took 1ms, data[100]=21
Both are built in Release mode (Linux->GCC, Win->MSVC).
It seems to me, that the automatic memory transfers do not work well under Windows.
Explicit memory transfers with
cudaMallocHost(&hostMem, size);
cudaMalloc(&cudaMem, size);
cudaMemcpy(hostMem, cudaMem, size, cudaMemcpyDeviceToHost);
cudaMemcpy(cudaMem, hostMem, size, cudaMemcpyHostToDevice);
work more or less with the same speed under Linux and Windows.
Why is there this big runtime difference between Linux and Windows when working with unified memory?

Answer 1

According to the documentation:
GPUs with SM architecture 6.x or higher (Pascal class or newer) provide additional Unified Memory features such as on-demand page migration and GPU memory oversubscription. [...] Applications running on Windows (whether in TCC or WDDM mode) will use the basic Unified Memory model as on pre-6.x architectures even when they are running on hardware with compute capability 6.x or higher.
Of the features explicitly mentioned here, I would think that "on-demand page migration" is very relevant for the increased performance under Linux.