0_Simple__MultiGPU

使用多台 GPU 进行计算

▶ 源代码。使用不同的流来控制不同 GPU 上的运算任务。

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

 const int MAX_GPU_COUNT = ;
 const int DATA_N        =  * ;

 __global__ static void reduceKernel(float *d_Result, float *d_Input, int N)
 {
     const int tid = blockIdx.x * blockDim.x + threadIdx.x;
     const int threadN = gridDim.x * blockDim.x;
     float sum = ;

     for (int pos = tid; pos < N; pos += threadN)
         sum += d_Input[pos];

     d_Result[tid] = sum;
 }

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

     const int BLOCK_N = , THREAD_N = ;
     const int ACCUM_N = BLOCK_N * THREAD_N;
     int i, j, GPU_N;
     float sumGPU;
     TGPUplan plan[MAX_GPU_COUNT];

     cudaGetDeviceCount(&GPU_N);
     GPU_N = MIN(GPU_N, MAX_GPU_COUNT);
     printf("\n\tDevice count: %i\n", GPU_N);

     // 准备计算数据
     for (i = ; i < GPU_N; i++)
         plan[i].dataN = DATA_N / GPU_N;

     // 计算数据量与设备数量没有对齐的部分
     for (i = ; i < DATA_N % GPU_N; i++)
         plan[i].dataN++;

     // 申请内存，初始化 h_data
     for (i = ; i < GPU_N; i++)
     {
         cudaSetDevice(i);
         cudaStreamCreate(&plan[i].stream);
         cudaMalloc((void **)&plan[i].d_data, plan[i].dataN * sizeof(float));
         cudaMalloc((void **)&plan[i].d_sum, ACCUM_N * sizeof(float));
         cudaMallocHost((void **)&plan[i].h_sum_from_device, ACCUM_N * sizeof(float));
         cudaMallocHost((void **)&plan[i].h_data, plan[i].dataN * sizeof(float));

         for (j = ; j < plan[i].dataN; j++)
             plan[i].h_data[j] = (float)rand() / (float)RAND_MAX;
     }

     StartTimer();// 计时

     // 调用各 GPU 进行计算，plan[i].d_data -> plan[i].d_sum -> plan[i].h_sum_from_device
     for (i = ; i < GPU_N; i++)
     {
         cudaSetDevice(i);
         cudaMemcpyAsync(plan[i].d_data, plan[i].h_data, plan[i].dataN * sizeof(float), cudaMemcpyHostToDevice, plan[i].stream);
         reduceKernel<<<BLOCK_N, THREAD_N, , plan[i].stream>>>(plan[i].d_sum, plan[i].d_data, plan[i].dataN);
         cudaMemcpyAsync(plan[i].h_sum_from_device, plan[i].d_sum, ACCUM_N *sizeof(float), cudaMemcpyDeviceToHost, plan[i].stream);
     }

     // 处理 GPU 计算结果，plan[i].h_sum_from_device -> plan[i].h_sum -> sumGPU
     for (i = ; i < GPU_N; i++)
     {
         cudaSetDevice(i);
         cudaStreamSynchronize(plan[i].stream);

         for (j = , plan[i].h_sum = 0.0f; j < ACCUM_N; j++)
             plan[i].h_sum += plan[i].h_sum_from_device[j];
     }
     for (i = , sumGPU = 0.0f; i < GPU_N; i++)// CPU 最后规约
         sumGPU += plan[i].h_sum;
     printf("\n\tGPU Processing time: %f (ms)\n", GetTimer());

     // 使用 CPU 计算，plan[i].h_data -> sumCPU
     double sumCPU = ;
     for (i = ; i < GPU_N; i++)
     {
         for (j = ; j < plan[i].dataN; j++)
             sumCPU += plan[i].h_data[j];
     }

     // 检查结果
     double diff = fabs(sumCPU - sumGPU) / fabs(sumCPU);
     printf("\n\tGPU sum: %f\n\tCPU sum: %f\n", sumGPU, sumCPU);
     printf("\n\tRelative difference: %E, %s\n", diff, (diff < 1e-) ? "Passed" : "Failed");

     //回收工作
     for (i = ; i < GPU_N; i++)
     {
         cudaSetDevice(i);
         cudaFreeHost(plan[i].h_data);
         cudaFreeHost(plan[i].h_sum_from_device);
         cudaFree(plan[i].d_sum);
         cudaFree(plan[i].d_data);
         cudaStreamDestroy(plan[i].stream);
     }

     getchar();
     return ;
 }

▶ 输出结果

    Start.

    Device count: 

    GPU Processing time: 13.726471 (ms)

    GPU sum: 16779778.000000
    CPU sum: 16779776.312309
    Relative difference: 1.005789E-07, Passed

▶ 涨姿势

● 在使用不同的设备执行相关函数（包括 cudaFree 等主机函数）时要注意，使用函数 cudaSetDevice() 来切换设备。