Cuda Memcpy from Device to Host crashes - c++

Question

I m trying to find a minimum of RGB around the patch size of 15 x 15
In source.cpp file at
SAFE_CALL(cudaMemcpy(Dark_h, Dark_d, size2, cudaMemcpyDeviceToHost));
program get crashed
Here is my code snippet
darkprior.h
#ifndef DARKPRIOR_H_INCLUDED
#define DARKPRIOR_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cuda.h"
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include "opencv2/opencv.hpp"
#define SAFE_CALL(call) \
do \
{ \
cudaError_t err = (call); \
if(cudaSuccess != err) \
{ \
fprintf(stderr,"CUDA Error:\nFile = %s\nLine = %d\nReason = %s\n", __FILE__, __LINE__, cudaGetErrorString(err)); \
cudaDeviceReset(); \
exit(EXIT_FAILURE); \
} \
} \
while (0)
void dark_channel(float *image_d, float *rgbmin_d, int height, int width);
#endif
Source.cpp
#include "DarkPrior.h"
#include <opencv2/opencv.hpp>
using namespace std;
using namespace cv;
int main()
{
//load the image
Mat src = imread("foggy_river.jpg");
//check whether image loaded is empty or not.
if (src.empty())
{
cerr << "no image"; return -1;
}
//Mat rgbMin(src.size(), CV_MAKETYPE(src.depth(), 1));
// int step = src.step;
float *image_h = NULL;
float *image_d = NULL;
float *Dark_d = NULL;
float *Dark_h = NULL;
//Mat rgbmin(src.size(), CV_MAKETYPE(src.depth(), 1));
size_t size1 = src.step * src.rows * sizeof(float);
size_t size2 = src.cols * src.rows * sizeof(float);
image_h = (float *)malloc(size1);
Dark_h = (float *)malloc(size1);
SAFE_CALL(cudaMalloc((void**)&image_d, size1));
SAFE_CALL(cudaMalloc((void**)&Dark_d, size2));
//convert image from CV::MAT to float*.
Mat dst;
src.convertTo(dst, CV_32F);
image_h = dst.ptr<float>();
SAFE_CALL(cudaMemcpy(image_d, image_h, size1, cudaMemcpyHostToDevice));
cout << "Calculating Minimum of RGB ..." << endl;
dark_channel(image_d, Dark_d, src.rows, src.cols);
SAFE_CALL(cudaMemcpy(Dark_h, Dark_d, size2, cudaMemcpyDeviceToHost));
Mat Dark_out(src.rows, src.cols, CV_32FC1, Dark_h);
imwrite("MinRGB.jpg", Dark_out);
cudaFree(image_d);
cudaFree(Dark_d);
//free(image_h);
//free(rgbmin_h);
return 0;
}
minRGB.cu
#include "DarkPrior.h"
//#define min(x,y) ((x<y)?x:y)
__device__ float safe_get(float *rgbMin, int width, int height, int x, int y)
{
// Clamp indices to image boundaries
x = min( max(0, x), width - 1);
y = min( max(0, y), height - 1);
// Translate 2D index into 1D index
const int idx = y * width + x ;
return rgbMin[idx];
}
__device__ float estimate_minimum_patch(float *rgbMin, int width, int height, int radius, int x, int y, float Minval)
{
for(int i = -radius; i <= radius; i++)
{
for(int j = -radius; j <= radius; j++)
{
float val = safe_get(rgbMin, width, height, x+i, y+j);
Minval = min (val, Minval);
}
}
}
__global__ void kernel_darkChannel (float *rgbMin, float *darkCh, int height, int width)
{
int radius = 7;
int x = blockIdx.x; // Current column
int y = blockIdx.y; // Current row
int tid = y * width + x;
float Minval = 255.0;
estimate_minimum_patch(rgbMin, width, height, radius, x, y, Minval);
darkCh[tid] = Minval;
}
__global__ void kernel_findMinRGB (float3 *image, float *tmp_min, int height, int width)
{
int x = blockIdx.x; // Current column
int y = blockIdx.y; // Current row
int i = y * width + x;
if(x > height && y > width)
{
return;
}
tmp_min[i] = min(image[i].x, min(image[i].y, image[i].z));
}
void dark_channel(float *image_d, float *Dark_d, int height, int width)
{
dim3 grid(width, height);
float *tmp_min;
cudaMalloc((void **)(&tmp_min), sizeof(float)*height*width);
kernel_findMinRGB <<<grid, 1>>> ((float3 *)image_d, tmp_min, height, width);
printf("RGB min is found\n");
kernel_darkChannel <<<grid, 1>>> (tmp_min, Dark_d, height, width);
printf("patch of minimum is also found\n");
return;
}
My code getting crashed with an error of unknown error # line 45 of source.cpp
I'm totally out of thoughts what is the reason, maybe you'll be able to help.

Answer 1

Pointer Dark_h points to host memory segment of size1 bytes. Pointer Dark_d points to device memory segment of size2 bytes. If size1 < size2 the call:
cudaMemcpy(Dark_h, Dark_d, size2, cudaMemcpyDeviceToHost)
will be troublesome as you'll write illegal memory (memory that's not part of array segment to which Dark_h points to, and perhaps you'll get SEGFAULT). I haven't tried it but I bet this is the reason behind the crash.