使用cuda c减少计算数组的总和

时间:2018-03-17 03:31:06

标签: c++ cuda

我遇到的一个问题是,当我运行我的cuda程序时,总是说在第167行的stats_gpu.cu中遇到了非法的内存访问。

代码如下:

#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>
#include <cuda.h>

#define MAXIMUM_VALUE   1000000.0f
#define HANDLE_ERROR( err )  ( HandleError( err, __FILE__, __LINE__ ) )

void HandleError( cudaError_t err, const char *file, int line ) {
  //
  // Handle and report on CUDA errors.
  //
  if ( err != cudaSuccess ) {
    printf( "%s in %s at line %d\n", cudaGetErrorString( err ), file, line );

    exit( EXIT_FAILURE );
  }
}

void checkCUDAError( const char *msg, bool exitOnError ) {
  //
  // Check cuda error and print result if appropriate.
  //
  cudaError_t err = cudaGetLastError();

  if( cudaSuccess != err) {
      fprintf(stderr, "Cuda error: %s: %s.\n", msg, cudaGetErrorString(err) );
      if (exitOnError) {
        exit(-1);
      }
  }
}

void cleanupCuda( void ) {
  //
  // Clean up CUDA resources.
  //

  //
  // Explicitly cleans up all runtime-related resources associated with the
  // calling host thread.
  //
  HANDLE_ERROR(
         cudaThreadExit()
         );
}

__device__ double device_pow( double x, double y ) {
  //
  // Calculate x^y on the GPU.
  //
  return pow( x, y );
}

//
// PLACE GPU KERNELS HERE - BEGIN
//
__global__ void kernel_calculate_sum(double *inputArray, double *outputArray, unsigned int n){
    extern __shared__ double sdata[];
    unsigned int i = threadIdx.x + blockIdx.x * blockDim.x;
    unsigned int tid = threadIdx.x;
    sdata[tid] = 0;
    while(i < n){
        sdata[tid] += inputArray[i];
        i += blockDim.x * gridDim.x;
    }
    __syncthreads();
    for(unsigned int s = blockDim.x/2; s > 0; s >>= 1){
        if(tid < s){
            sdata[tid] += sdata[tid + s];
        }
        __syncthreads();
    }
    if(tid == 0){
        outputArray[blockIdx.x] = sdata[0];
    }

}

//
// PLACE GPU KERNELS HERE - END
//

int main( int argc, char* argv[] ) {
  //
  // Determine min, max, mean, mode and standard deviation of array
  //
  unsigned int array_size, seed, i;
  struct timeval start, end;
  float runtime;

  if( argc < 3 ) {
    printf( "Format: stats_gpu <size of array> <random seed>\n" );
    printf( "Arguments:\n" );
    printf( "  size of array - This is the size of the array to be generated and processed\n" );
    printf( "  random seed   - This integer will be used to seed the random number\n" );
    printf( "                  generator that will generate the contents of the array\n" );
    printf( "                  to be processed\n" );

    exit( 1 );
  }

  //
  // Get the size of the array to process.
  //
  array_size = atoi( argv[1] );

  //
  // Get the seed to be used
  //
  seed = atoi( argv[2] );

  //
  // Make sure that CUDA resources get cleaned up on exit.
  //
  atexit( cleanupCuda );

  //
  // Record the start time.
  //
  gettimeofday( &start, NULL );

  //
  // Allocate the array to be populated.
  //
  double *array = (double *) malloc( array_size * sizeof( double ) );

  //
  // Seed the random number generator and populate the array with its values.
  //
  srand( seed );
  for( i = 0; i < array_size; i++ )
    array[i] = ( (double) rand() / (double) RAND_MAX ) * MAXIMUM_VALUE;

  //
  // Setup output variables to hold min, max, mean, and standard deviation
  //
  // YOUR CALCULATIONS BELOW SHOULD POPULATE THESE WITH RESULTS
  //
  double min = DBL_MAX;
  double max = 0;
  double sum = 0;
  double mean = 0;
  double stddev = 0;

  unsigned int threadsPerBlock = 512;
  unsigned int blocksPerGrid = (65535 < (array_size + threadsPerBlock - 1) / threadsPerBlock)?65535:(array_size + threadsPerBlock - 1) / threadsPerBlock;

  double *dev_input_array, *dev_output_array, *outputArray;
  outputArray = (double*)malloc( blocksPerGrid * sizeof(double) );


  //
  // CALCULATE VALUES FOR MIN, MAX, MEAN, and STDDEV - BEGIN
  //
  //Allocate memory on GPU
  HANDLE_ERROR( cudaMalloc( (void**) &dev_input_array, array_size * sizeof( double ) ) );
  HANDLE_ERROR( cudaMalloc( (void**) &dev_output_array, blocksPerGrid * sizeof( double ) ) );
  //Copy data from host to GPU
  HANDLE_ERROR( cudaMemcpy( dev_input_array, array, array_size * sizeof(double), cudaMemcpyHostToDevice ) );
  //Execute kernel on GPU
  kernel_calculate_sum<<<blocksPerGrid, threadsPerBlock>>>(dev_input_array, dev_output_array, array_size);

  //Copy data from GPU to host
  HANDLE_ERROR( cudaMemcpy(outputArray, dev_output_array, blocksPerGrid * sizeof( double ), cudaMemcpyDeviceToHost));
  for(unsigned int j = 0; j < blocksPerGrid; j++){
    sum += outputArray[j];
  }

  //Deallocate memory on GPU
  cudaFree(dev_input_array);
  cudaFree(dev_output_array);

  //
  // CALCULATE VALUES FOR MIN, MAX, MEAN, and STDDEV - END
  //

  //
  // Record the end time.
  //
  gettimeofday( &end, NULL );

  //
  // Calculate the runtime.
  //
  runtime = ( ( end.tv_sec  - start.tv_sec ) * 1000.0 ) + ( ( end.tv_usec - start.tv_usec ) / 1000.0 );

  //
  // Output discoveries from the array.
  //
  printf( "Statistics for array ( %d, %d ):\n", array_size, seed );
  printf( "    Minimum = %4.6f, Maximum = %4.6f\n", min, max );
  printf( "    Mean = %4.6f, Standard Deviation = %4.6f\n", mean, stddev );
  printf( "Processing Time: %4.4f milliseconds\n", runtime );

  //
  // Free the allocated array.
  //
  free( array );
  free(outputArray);

  return 0;
}

1 个答案:

答案 0 :(得分:0)

内核调用后,cudaMemcpy操作报告的错误发生在:

HANDLE_ERROR( cudaMemcpy(outputArray, dev_output_array, blocksPerGrid * sizeof( double ), cudaMemcpyDeviceToHost));

(将来,如果您发现这是代码中的第167行,则对其他人有帮助)

CUDA内核错误报告是异步的,因此该错误实际上表明内核代码中存在非法内存访问。

如果您使用cuda-memcheck运行代码,您会看到很多这样的迹象:

========= Invalid __shared__ write of size 8
=========     at 0x00000068 in /.../....cu:64:kernel_calculate_sum(double*, double*, unsigned int)
=========     by thread (0,0,0) in block (0,0,0)
=========     Address 0x00000000 is out of bounds
...

所以共享内存访问有问题。使用动态分配的共享内存时,如下所示:

extern __shared__ double sdata[];

有必要将共享内存的大小作为内核参数传递。但你不是这样做的:

kernel_calculate_sum<<<blocksPerGrid, threadsPerBlock>>>(dev_input_array, dev_output_array, array_size);
                                                     ^
                                          missing shared size parameter

因此您的共享内存访问失败。对内核调用的简单修改:

kernel_calculate_sum<<<blocksPerGrid, threadsPerBlock, threadsPerBlock*sizeof(double)>>>(dev_input_array, dev_output_array, array_size);

解决了这个错误。这是必要的,因为您的内核每个线程需要一个double数量,因此您必须保留线程块的大小乘以double的大小。