Question

在我目前的项目中，我使用GPU进行信号处理和可视化。我已经在使用流来允许异步操作。信号在帧中处理，对于每个帧，流中的处理步骤如下

memcpy to device
信号调节
图像处理
可视化

目前这些步骤正在单个GPU上进行，但我的机器有一个多GPU卡（GeForce GTX 690），我想在这两个设备之间分配操作。基本上我想在设备 A 上执行步骤1和2，在设备 B 上执行步骤3和4，而操作1,2,3和4仍然执行作为单个异步流。期望的结果是流式布局，看起来像这样

Device A Stream a 1 2       1 2  ...
         Stream b      1 2  ...
Device B Stream a    3 4       3 4 ...
         Stream b         3 4  ...

我该怎么做？

Answer 1

我之前的尝试不正确，因为流与其创建的设备相关联。因此，我认为标题中提出的问题最直接的答案是“它无法完成”。您无法创建单个流并向其发出多个GPU的命令。来自here：

Stream and Event Behavior

A kernel launch or memory copy will fail if it is issued to a stream that is not associated to the current device

然而，在研究它时，我注意到事件是在两个不同设备上同步两个流的建议方法：

即使输入流和输入，
cudaStreamWaitEvent()也会成功事件与不同的设备相关联。 cudaStreamWaitEvent（）可以因此可用于将多个设备相互同步。

所以就这样，我创建了以下代码来说明这一点：

#include <stdio.h>
#define SIZE 32
#define K1VAL 5
#define K3VAL 3

#define cudaCheckErrors(msg) \
    do { \
        cudaError_t __err = cudaGetLastError(); \
        if (__err != cudaSuccess) { \
            fprintf(stderr, "Fatal error: %s (%s at %s:%d)\n", \
                msg, cudaGetErrorString(__err), \
                __FILE__, __LINE__); \
            fprintf(stderr, "*** FAILED - ABORTING\n"); \
            exit(1); \
        } \
    } while (0)


__global__ void kernel1(int *frame, int size){

  int idx = threadIdx.x + (blockDim.x * blockIdx.x);

  if (idx == 0){
   int *a = new int[10000]; // just to make this kernel take a while
   for (int i = 0; i<10000; i++)
     a[i] = 0;
   for (int i = 0; i < size; i++)
     frame[i] += K1VAL;
   }
}


__global__ void kernel3(int *frame, int size){

  int idx = threadIdx.x + (blockDim.x * blockIdx.x);
  if (idx == 0)
   for (int i = 0; i < size; i++)
     frame[i] -= K3VAL;
}

void set_device(int dev){
  int ldev;
  cudaSetDevice(dev);
  cudaGetDevice(&ldev);
  cudaCheckErrors("set device error");
  if (ldev != dev){
    printf("set device mismatch error\n");
    exit(1);
    }
}


int main(){

  int A=0;
  int B=1;
  int framesize = SIZE*sizeof(int);
  int *h_frame;
  int *d_frame_aA,  *d_frame_bB;
  int numdev = 0;
  cudaGetDeviceCount(&numdev);
  cudaCheckErrors("can't determine number of devices");
  if (numdev < 2){
   printf("not enough devices!\n");
   return 1;
   }
  set_device(A);
  cudaMalloc((void **) &d_frame_aA, framesize);  // stream_a
  cudaMemset(d_frame_aA, 0, framesize);
  set_device(B);
  cudaMalloc((void **) &d_frame_bB, framesize);  // stream_b
  cudaMemset(d_frame_bB, 0, framesize);
  cudaHostAlloc((void **) &h_frame, framesize, cudaHostAllocDefault);
  cudaCheckErrors("allocations failure");

  set_device(A);
  cudaStream_t stream_a, stream_b;
  cudaStreamCreate(&stream_a);
  cudaEvent_t absync;
  cudaEventCreate(&absync);
  set_device(B);
  cudaStreamCreate(&stream_b);
  cudaCheckErrors("stream creation failure");


  for (int i = 0; i < SIZE; i++)
    h_frame[i] = 0;

  set_device(A);
  cudaDeviceEnablePeerAccess(B, 0);
  set_device(B);
  cudaDeviceEnablePeerAccess(A, 0);
  cudaCheckErrors("enable peer access fail");


  set_device(A);
  cudaMemcpyAsync(d_frame_aA, h_frame, framesize, cudaMemcpyHostToDevice, stream_a);
  kernel1<<<1,1,0, stream_a>>>(d_frame_aA, SIZE);
  cudaCheckErrors("kernel1 fail");
  cudaMemcpyPeerAsync(d_frame_bB, B, d_frame_aA, A, framesize, stream_a );
  cudaCheckErrors("memcpypeer fail");
  cudaEventRecord(absync, stream_a);
  set_device(B);
  // comment out the next line to see the failure
  cudaStreamWaitEvent(stream_b, absync, 0);
  kernel3<<<1,1,0, stream_b>>>(d_frame_bB, SIZE);
  cudaCheckErrors("main sequence fail");


//  cudaCheckErrors("main sequence failure");

  cudaMemcpy(h_frame, d_frame_bB, framesize, cudaMemcpyDeviceToHost);
  cudaCheckErrors("results_a memcpy fail");
  for (int i = 0; i < SIZE; i++)
    if (h_frame[i] != (K1VAL - K3VAL)) {
      printf("results error\n");
      return 1;
      }
  printf("success\n");
  return 0;

}

如果您按原样运行代码，则应收到success消息。如果您注释掉强制流b（在设备B上）等待流a（在设备A上）的行，那么您将看到results error消息。因此，这演示了如何将一个设备上的流同步到另一个设备上的流。希望能帮助到你。对不起第一轮的混乱。

Answer 2

cudaStreamWaitEvent()启用GPU间同步，因为您可以在属于另一个设备的CUDA事件上插入等待。

因此，生产者和消费者之间的GPU间同步所需要的是为2个GPU中的每一个分配一些事件（至少2个），然后让生产者cudaEventRecord()和消费者{{ 1}}在同一事件上。 cudaStreamWaitEvent()将命令插入当前设备的命令缓冲区，使其暂停执行，直到记录了给定的事件。

下面是一个代码片段，其中以这种方式使用cudaStreamWaitEvent()实现点对点memcpy。泵启动后，生产者和消费者应同时进行PCIe传输，每个传输到两个临时缓冲区之一（在便携式固定内存中分配）。

cudaStreamWaitEvent()

https://github.com/ArchaeaSoftware/cudahandbook/blob/master/memory/peer2peerMemcpy.cu

中的完整源代码

在单个流中使用对等GPU

2 个答案: