cuda中当元素个数超过线程个数时的处理案例

项目打包下载

当向量元素超过线程个数时的情况

向量元素个数为（33 * 1024）/（128 * 128）=2.x倍

 /*
 * 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 "cuda_runtime.h"
 #include "device_launch_parameters.h"

 #define N   (33 * 1024)

 __global__ void add(int *a, int *b, int *c) {
     int tid = threadIdx.x + blockIdx.x * blockDim.x;
     while (tid < N) {
         c[tid] = a[tid] + b[tid];
         tid += blockDim.x * gridDim.x;
     }
 }

 int main(void) {
     int *a, *b, *c;
     int *dev_a, *dev_b, *dev_c;

     // allocate the memory on the CPU
     a = (int*)malloc(N * sizeof(int));
     b = (int*)malloc(N * sizeof(int));
     c = (int*)malloc(N * sizeof(int));

     // allocate the memory on the GPU
     HANDLE_ERROR(cudaMalloc((void**)&dev_a, N * sizeof(int)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_b, N * sizeof(int)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_c, N * sizeof(int)));

     // fill the arrays 'a' and 'b' on the CPU
     for (int i = ; i<N; i++) {
         a[i] = i;
         b[i] =  * i;
     }

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

     /*
     当向量元素超过线程个数时的情况
     向量元素个数为（33 * 1024）/（128 * 128）=2.x倍
     */
     add << <,  >> >(dev_a, dev_b, dev_c);

     // copy the array 'c' back from the GPU to the CPU
     HANDLE_ERROR(cudaMemcpy(c, dev_c, N * sizeof(int),
         cudaMemcpyDeviceToHost));

     // verify that the GPU did the work we requested
     bool success = true;
     for (int i = ; i<N; i++) {
         if ((a[i] + b[i]) != c[i]) {
             printf("Error:  %d + %d != %d\n", a[i], b[i], c[i]);
             success = false;
         }
     }
     if (success)    printf("We did it!\n");

     // free the memory we allocated on the GPU
     HANDLE_ERROR(cudaFree(dev_a));
     HANDLE_ERROR(cudaFree(dev_b));
     HANDLE_ERROR(cudaFree(dev_c));

     // free the memory we allocated on the CPU
     free(a);
     free(b);
     free(c);

     return ;
 }