Optimization Cudamalochost与malloc在性能上的表现并无差异

我经历过这一切。从这里我得到了使用cudamalochost的固定内存比cudamaloc提供了更好的性能。然后我使用了两个不同的简单程序，测试了执行时间

使用cudamalochost

#include <stdio.h>
#include <cuda.h>

// Kernel that executes on the CUDA device
__global__ void square_array(float *a, int N)
{
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  if (idx<N) a[idx] = a[idx] * a[idx];
}

// main routine that executes on the host
int main(void)
{
    clock_t start;
    start=clock();/* Line 8 */
    clock_t finish;
  float *a_h, *a_d;  // Pointer to host & device arrays
  const int N = 100000;  // Number of elements in arrays
  size_t size = N * sizeof(float);
  cudaMallocHost((void **) &a_h, size);
  //a_h = (float *)malloc(size);        // Allocate array on host
  cudaMalloc((void **) &a_d, size);   // Allocate array on device
  // Initialize host array and copy it to CUDA device
  for (int i=0; i<N; i++) a_h[i] = (float)i;
  cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);
  // Do calculation on device:
  int block_size = 4;
  int n_blocks = N/block_size + (N%block_size == 0 ? 0:1);
  square_array <<< n_blocks, block_size >>> (a_d, N);
  // Retrieve result from device and store it in host array
  cudaMemcpy(a_h, a_d, sizeof(float)*N, cudaMemcpyDeviceToHost);
  // Print results
  for (int i=0; i<N; i++) printf("%d %f\n", i, a_h[i]);
  // Cleanup
  cudaFreeHost(a_h);
  cudaFree(a_d);
  finish = clock() - start;
      double interval = finish / (double)CLOCKS_PER_SEC; 
      printf("%f seconds elapsed", interval);
}

#包括
#包括
//在CUDA设备上执行的内核
__全局数组（浮点*a，整数N）
{
int idx=blockIdx.x*blockDim.x+threadIdx.x；
如果（idx如果您想查看复制操作的执行时间差异，只需对复制操作计时。在许多情况下，当底层mememory被固定时，您将看到复制操作的执行时间差异约为2倍。请将复制操作设置为足够大/足够长，以使您远远高于granul您正在使用的任何计时机制的多样性。各种各样的工具，如VisualProfiler和
nvprof
可以在这里提供帮助

引擎盖下的
cudamalochost
操作执行类似于
malloc
的操作，并添加操作系统功能以“锁定”与分配相关联的每个页面。与只执行
malloc
相比，这些额外的操作系统操作需要额外的时间。请注意，随着分配大小的增加，注册（“固定”）成本通常也会增加

因此，对于许多示例来说，仅仅对整体执行进行计时并没有显示出太大的差异，因为虽然从固定内存执行
cudaMemcpy
操作可能更快，但是
cudaMallocHost
比相应的
malloc
花费的时间更长

那有什么意义呢

当您将从单个缓冲区重复传输时，您可能对使用固定内存（即
cudamalochost
）感兴趣。您只需支付固定一次的额外费用，但每次传输/使用都会使您受益
将数据传输操作（
cudaMemcpyAsync
）与计算活动（内核调用）重叠需要固定内存。请参阅
我也发现仅仅在一段内存中声明cudaHostAlloc/cudamalochost并没有多大作用。
可以肯定的是，使用--print gpu跟踪进行nvprof，然后查看memcpyHtoD或memcpyDtoH的吞吐量是否良好。对于PCI2.0，您应该获得大约6-8gbps的吞吐量

然而，固定内存是cudaMemcpyAsync的额外条件。
在我调用cudaMemcpyAsync之后，我转移了主机上所有的计算，这样你就可以用主机计算“分层”异步memcpy

我很惊讶这样可以节省大量时间，值得一试。
仅100000个元素几乎看不出有什么不同。您可能需要运行“带宽测试”来自的CUDA示例。它运行一个更复杂的测试，其中差异应该是可见的。内存传输可能只是您正在测量的时间的一小部分。使用更高分辨率的计时器，仅测量cudaMemcpy调用，您可能会注意到差异。或者使用CUDA toolkit适用于您的平台。如果我取较大的N值，如N=16*1024*1024，结果与预期不符。它们不是平方根，而是“I”的值。为什么会出现这种异常行为？我还尝试使用malloc（）而不是cudaHostMalloc（）。
#include <stdio.h>
#include <cuda.h>

// Kernel that executes on the CUDA device
__global__ void square_array(float *a, int N)
{
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  if (idx<N) a[idx] = a[idx] * a[idx];
}

// main routine that executes on the host
int main(void)
{
    clock_t start;
    start=clock();/* Line 8 */
    clock_t finish;
  float *a_h, *a_d;  // Pointer to host & device arrays
  const int N = 100000;  // Number of elements in arrays
  size_t size = N * sizeof(float);
  a_h = (float *)malloc(size);        // Allocate array on host
  cudaMalloc((void **) &a_d, size);   // Allocate array on device
  // Initialize host array and copy it to CUDA device
  for (int i=0; i<N; i++) a_h[i] = (float)i;
  cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);
  // Do calculation on device:
  int block_size = 4;
  int n_blocks = N/block_size + (N%block_size == 0 ? 0:1);
  square_array <<< n_blocks, block_size >>> (a_d, N);
  // Retrieve result from device and store it in host array
  cudaMemcpy(a_h, a_d, sizeof(float)*N, cudaMemcpyDeviceToHost);
  // Print results
  for (int i=0; i<N; i++) printf("%d %f\n", i, a_h[i]);
  // Cleanup
  free(a_h); cudaFree(a_d);
  finish = clock() - start;
      double interval = finish / (double)CLOCKS_PER_SEC; 
      printf("%f seconds elapsed", interval);
}