0_Simple__simpleZeroCopy

两种方法使用零拷贝内存做简单的向量加和，并评估 GPU 计算结果与 CPU 计算结果的差。

▶ 源代码

 #include <stdio.h>
 #include <cuda.h>
 #include <cuda_runtime.h>
 #include "device_launch_parameters.h"
 #include <helper_functions.h>
 #include <helper_cuda.h>

 #define MEMORY_ALIGNMENT  4096
 #define ALIGN_UP(x,size) ( ((size_t)x+(size-1))&(~(size-1)) )

 __global__ void vectorAddGPU(float *a, float *b, float *c, int N)
 {
     int idx = blockIdx.x*blockDim.x + threadIdx.x;
     if (idx < N)
         c[idx] = a[idx] + b[idx];
 }

 int main(int argc, char **argv)
 {
     printf("\n\tStart.\n");

     // 设备检查
     bool bMac;
     cudaDeviceProp deviceProp;
     cudaSetDevice();
     cudaGetDeviceProperties(&deviceProp, );
     if (CUDART_VERSION <  || !deviceProp.canMapHostMemory)// CUDART_VERSION 为 CUDA Runtime API 版本，CUDA9.0 对应 9000
     {
         printf("\n\t CUDA Runtime API not support MapHostMemory.\n");
         getchar();
         return ;
     }
     cudaSetDeviceFlags(cudaDeviceMapHost);// MapHostFlag 功能正常，设置标志
 #if defined(__APPLE__) || defined(MACOSX)// MacOS 系统不支持将普通堆内存设置为页锁定内存
     bMac = true;
 #else
     bMac = false;
 #endif
     if (CUDART_VERSION <  && !bMac)// 既不是 MacOS 系统，Runtime API 版本还不够高
     {
         printf("\n\tCUDA Runtime API not support cudaHostRegister function.\n");
         getchar();
         return ;
     }
     // 总体逻辑：
     // CUDA Runtime version < 2200，不支持 MApHostMamory，退出
     // CUDA Runtime version ∈[2200, 4000)，且为 MAcOS 系统，使用 cudaHostAlloc() + cudaHostAllocMapped
     // CUDA Runtime version ∈[2200, 4000)，且不是 MAcOS 系统，退出
     // CUDA Runtime version ≥ 4000，使用 malloc() + cudaHostRegister()

     // 内存申请
     int nelem = ;
     int bytes = nelem * sizeof(float);
     float *a, *b, *c;
     float *a_UA, *b_UA, *c_UA;
     float *d_a, *d_b, *d_c;
     if (CUDART_VERSION >=  || bMac)
     {
         a_UA = (float *) malloc(bytes + MEMORY_ALIGNMENT);      // 申请时多 4KB，用于滑动对齐，释放内存时以该指针为准
         b_UA = (float *) malloc(bytes + MEMORY_ALIGNMENT);
         c_UA = (float *) malloc(bytes + MEMORY_ALIGNMENT);
         a = (float *) ALIGN_UP(a_UA, MEMORY_ALIGNMENT);         // 指针指到 4K 对齐的位置上去，用于计算
         b = (float *) ALIGN_UP(b_UA, MEMORY_ALIGNMENT);
         c = (float *) ALIGN_UP(c_UA, MEMORY_ALIGNMENT);
         cudaHostRegister(a, bytes, CU_MEMHOSTALLOC_DEVICEMAP);  // 设置页锁定内存
         cudaHostRegister(b, bytes, CU_MEMHOSTALLOC_DEVICEMAP);
         cudaHostRegister(c, bytes, CU_MEMHOSTALLOC_DEVICEMAP);
     }
     else
     {
         cudaHostAlloc((void **)&a, bytes, cudaHostAllocMapped); // 使用函数 cudaHostAlloc() 一步到位
         cudaHostAlloc((void **)&b, bytes, cudaHostAllocMapped);
         cudaHostAlloc((void **)&c, bytes, cudaHostAllocMapped);
     }

     // 初始化和内存映射
     for (int n = ; n < nelem; n++)
     {
         a[n] = rand() / (float)RAND_MAX;
         b[n] = rand() / (float)RAND_MAX;
     }
     cudaHostGetDevicePointer((void **)&d_a, (void *)a, );
     cudaHostGetDevicePointer((void **)&d_b, (void *)b, );
     cudaHostGetDevicePointer((void **)&d_c, (void *)c, );

     // 调用内核
     dim3 block(, , );
     dim3 grid((unsigned int)ceil(nelem / (float)block.x));
     vectorAddGPU << <grid, block >> > (d_a, d_b, d_c, nelem);
     cudaDeviceSynchronize();

     // 检查结果
     float errorNorm, refNorm, ref, diff;
     errorNorm = .f;
     refNorm = .f;
     for (int n = ; n < nelem; n++)
     {
         diff = c[n] - (ref = a[n] + b[n]);// ref 为 CPU 计算的和，diff 为 GPU 计算结果与 CPU 计算结果的差
         errorNorm += diff*diff;           // 向量 a + b 的两种计算结果的差的平方
         refNorm += ref*ref;               // 向量 a 与向量 b 的和的平方
     }
     errorNorm = (float)sqrt((double)errorNorm);
     refNorm = (float)sqrt((double)refNorm);
     printf("\n\tDifference between GPU and CPU is %f, %f%%\n", errorNorm, errorNorm / refNorm);

     // 清理工作
     if (CUDART_VERSION >=  || bMac)
     {
         cudaHostUnregister(a);
         cudaHostUnregister(b);
         cudaHostUnregister(c);
         free(a_UA);
         free(b_UA);
         free(c_UA);
     }
     else
     {
         cudaFreeHost(a);
         cudaFreeHost(b);
         cudaFreeHost(c);
     }
     printf("\n\tFinish.\n");
     getchar();
     return ;
 }

▶ 输出结果：

     Start.
     Difference between GPU and CPU is 0.000000, 0.000000%

     Finish.

▶ 涨姿势

● 两种使用零拷贝内存的方法，在代码的逻辑部分进行了说明

● 向上取整的宏函数，只对分母（size）为 2 的整数次幂的情况有效。

 #define ALIGN_UP(x,size) ( ((size_t)x+(size-1))&(~(size-1)) )

　　e.g. size == 4096，则 ~ (size - 1) == 11111111 11111111 11110000 00000000₂，将其作为模板进行按位且操作，等价于取不低于 4096 的高位。