C++ Cuda 메모리 할당에서의 예외 처리

Cuda 프로그래밍에 있어서 메모리 할당 시에는 예외 처리를 잘 해야 한다.

사소한 메모리 관리를 놓치면, 프로젝트가 망가질 수 있다.

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
 
#include <stdlib.h>
#include <cstring>
#include <time.h>
#include <stdio.h>
#include <iostream>
 
#define gpuErrchk(ans) { gpuAssert(ans, __FILE__, __LINE__); }
inline void gpuAssert(cudaError_t code, const char* file, int line, bool abort = true)
{
    if (code != cudaSuccess)
    {
        printf("Error 발생!\n");
        fprintf(stderr, "GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
        if (abort) exit(code);
    }
}
 
void sum_array_cpu(int* a, int* b, int* c, int size)
{
    for (int i = 0; i < size; i++)
    {
            c[i] = a[i] + b[i];
    }
}
 
__global__ void sum_array_gpu(int* a, int* b, int * c, int size)
{
    int gid = blockIdx.x * blockDim.x + threadIdx.x;
 
    if (gid < size)
    {
        c[gid] = a[gid] + b[gid];
    }
}
 
void compare_arrays(int* a, int* b, int size)
{
    for (int i = 0; i < size; i++)
    {
        if (a[i] != b[i])
        {
            printf("a[i] : %d, b[i] : %d\n", a[i], b[i]);
            printf("다른 배열!\n");
        return;
        }
    }
 
    printf("같은 배열! \n");
}
 
int main()
{
    int size = 1 << 28;
    printf("size : %d\n", size);
 
    int block_size = 1024;
 
    int NO_BYTES = size * sizeof(int);
    int* h_a, * h_b, * gpu_results, * h_c;
 
    if ((h_a = (int*)malloc(NO_BYTES)) == NULL ||
        (h_b = (int*)malloc(NO_BYTES)) == NULL ||
        (h_c = (int*)malloc(NO_BYTES)) == NULL ||
        (gpu_results = (int*)malloc(NO_BYTES)) == NULL)
    {
        fprintf(stderr, "메모리 부족");
        exit(EXIT_FAILURE);
    }
 
    time_t t;
    srand((unsigned)time(&t));
    for (int i = 0; i < size; i++)
    {
        h_a[i] = (int)(rand() & 0xFF);
 
    }
 
    for (int i = 0; i < size; i++)
    {
        h_b[i] = (int)(rand() & 0xFF);
    }
    memset(h_c, 0, NO_BYTES);
    memset(gpu_results, 0, NO_BYTES);
    
    int* d_a, * d_b, * d_c;
    gpuErrchk(cudaMalloc((int**)&d_a, NO_BYTES));
    
    gpuErrchk(cudaMalloc((int**)&d_b, NO_BYTES));
    gpuErrchk(cudaMalloc((int**)&d_c, NO_BYTES));
 
    cudaMemcpy(d_a, h_a, NO_BYTES, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, NO_BYTES, cudaMemcpyHostToDevice);
 
    dim3 block(block_size);
    dim3 grid(size / block.x + 1);
    
    sum_array_gpu << <grid, block >> > (d_a, d_b, d_c, size);
    sum_array_cpu(h_a, h_b, h_c, size);
    cudaDeviceSynchronize();
    
    cudaMemcpy(gpu_results, d_c, NO_BYTES, cudaMemcpyDeviceToHost);
 
    compare_arrays(gpu_results, h_c, size);
 
 
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
 
    free(h_a);
    free(h_b);
    free(h_c);
    free(gpu_results);
    return 0;
}