多GPU设备处理点积示例

多GPU设备处理点积示例，项目打包下载

 /*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */

 #include "../common/book.h"
 #include "cuda.h"
 #include "device_launch_parameters.h"
 #include "device_functions.h"
 #include "cuda_runtime.h"

 #define imin(a,b) (a<b?a:b)

 #define     N    (33*1024*1024)
 const int threadsPerBlock = ;
 const int blocksPerGrid =
 imin(, (N /  + threadsPerBlock - ) / threadsPerBlock);

 __global__ void dot(int size, float *a, float *b, float *c) {
     __shared__ float cache[threadsPerBlock];
     int tid = threadIdx.x + blockIdx.x * blockDim.x;
     int cacheIndex = threadIdx.x;

     float   temp = ;
     while (tid < size) {
         temp += a[tid] * b[tid];
         tid += blockDim.x * gridDim.x;
     }

     // set the cache values
     cache[cacheIndex] = temp;

     // synchronize threads in this block
     __syncthreads();

     //块内归约
     int i = blockDim.x / ;
     while (i != ) {
         if (cacheIndex < i)
             cache[cacheIndex] += cache[cacheIndex + i];
         __syncthreads();
         i /= ;
     }

     if (cacheIndex == )
         c[blockIdx.x] = cache[];
 }

 struct DataStruct {
     int     deviceID;
     int     size;
     float   *a;
     float   *b;
     float   returnValue;
 };

 unsigned WINAPI routine(void *pvoidData)
 //void* routine(void *pvoidData)
 {
     DataStruct  *data = (DataStruct*)pvoidData;
     HANDLE_ERROR(cudaSetDevice(data->deviceID));

     int     size = data->size;
     float   *a, *b, c, *partial_c;
     float   *dev_a, *dev_b, *dev_partial_c;

     // allocate memory on the CPU side
     a = data->a;
     b = data->b;
     partial_c = (float*)malloc(blocksPerGrid*sizeof(float));

     // allocate the memory on the GPU
     HANDLE_ERROR(cudaMalloc((void**)&dev_a,
         size*sizeof(float)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_b,
         size*sizeof(float)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_partial_c,
         blocksPerGrid*sizeof(float)));

     // copy the arrays 'a' and 'b' to the GPU
     HANDLE_ERROR(cudaMemcpy(dev_a, a, size*sizeof(float),
         cudaMemcpyHostToDevice));
     HANDLE_ERROR(cudaMemcpy(dev_b, b, size*sizeof(float),
         cudaMemcpyHostToDevice));

     dot <<<blocksPerGrid, threadsPerBlock >>>(size, dev_a, dev_b,
         dev_partial_c);
     // copy the array 'c' back from the GPU to the CPU
     HANDLE_ERROR(cudaMemcpy(partial_c, dev_partial_c,
         blocksPerGrid*sizeof(float),
         cudaMemcpyDeviceToHost));

     // finish up on the CPU side
     c = ;
     for (int i = ; i<blocksPerGrid; i++) {
         c += partial_c[i];
     }

     HANDLE_ERROR(cudaFree(dev_a));
     HANDLE_ERROR(cudaFree(dev_b));
     HANDLE_ERROR(cudaFree(dev_partial_c));

     // free memory on the CPU side
     free(partial_c);

     data->returnValue = c;
     return ;
 }

 int main(void) {
     int deviceCount;
     HANDLE_ERROR(cudaGetDeviceCount(&deviceCount));
     //要求两个设备
     if (deviceCount < ) {
         printf("We need at least two compute 1.0 or greater "
             "devices, but only found %d\n", deviceCount);
         return ;
     }

     float   *a = (float*)malloc(sizeof(float)* N);
     HANDLE_NULL(a);
     float   *b = (float*)malloc(sizeof(float)* N);
     HANDLE_NULL(b);

     // fill in the host memory with data
     for (int i = ; i<N; i++) {
         a[i] = i;
         b[i] = i * ;
     }

     /*
     为多线程做准备
     每个DateStruct都为数据集大小的一半
     */
     DataStruct  data[];
     data[].deviceID = ;
     data[].size = N / ;
     data[].a = a;
     data[].b = b;

     data[].deviceID = ;
     data[].size = N / ;
     data[].a = a + N / ;
     data[].b = b + N / ;

     CUTThread   thread = start_thread(routine, &(data[]));
     routine(&(data[]));
     end_thread(thread);

     // free memory on the CPU side
     free(a);
     free(b);

     printf("Value calculated:  %f\n",
         data[].returnValue + data[].returnValue);

     return ;
 }