Gaussian Image Blurring using CUDA C/C++ [closed] - cuda

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 3 years ago.
Improve this question
I am trying to apply gaussian image blurring using CUDA C/C++ programming. The CPU part is working good with producing a good result. But, in the case of GPU, it's producing only a black image. I am not sure where is the problem. Here is my full code.
How can I resolve this issue?
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#define IMW 1600
#define IMH 1600
#define CHANNEL_NUM 3
#define IMAGE_BUFFER_SIZE (IMW*IMH*CHANNEL_NUM)
#define BLOCKX 16
#define BLOCKY BLOCKX
#define BLUR_DEGREE 3
#define BLUR_SIZE 1
unsigned int width, height;
int hmask[3][3] = { 1, 2, 1,
2, 4, 2,
1, 2, 1
};
#include <time.h>
#include <sys/time.h>
#define USECPSEC 1000000ULL
__global__ void blurKernel(unsigned char * in, unsigned char * out, int w, int h)
{
int Col = blockIdx.x * blockDim.x + threadIdx.x;
int Row = blockIdx.y * blockDim.y + threadIdx.y;
if (Col < w && Row < h)
{
int pixVal = 0;
int pixels = 0;
// Get the average of the surrounding BLUR_SIZE x BLUR_SIZE box
for(int blurRow = -BLUR_SIZE; blurRow < BLUR_SIZE+1; ++blurRow)
{
for(int blurCol = -BLUR_SIZE; blurCol < BLUR_SIZE+1; ++blurCol)
{
int curRow = Row + blurRow;
int curCol = Col + blurCol;
// Verify we have a valid image pixel
if(curRow > -1 && curRow < h && curCol > -1 && curCol < w)
{
pixVal += in[curRow * w + curCol];
pixels++; // Keep track of number of pixels in the avg
}
}
}
// Write our new pixel value out
out[Row * w + Col] = (unsigned char)(pixVal / pixels);
}
}
int main(int argc, char **argv)
{
/************ Setup work ***********************/
unsigned char *d_resultPixels;
unsigned char *h_resultPixels;
unsigned char *h_devicePixels;
unsigned char *h_pixels = NULL;
unsigned char *d_pixels = NULL;
int nBlurDegree;
int imageSize = sizeof(unsigned char) * IMAGE_BUFFER_SIZE;
h_pixels = (unsigned char *)malloc(imageSize);
h_resultPixels = (unsigned char *)malloc(imageSize);
h_devicePixels = (unsigned char *)malloc(imageSize);
int width1, height1, bpp;
h_pixels = stbi_load("rana_1600_1600.png", &width1, &height1, &bpp, CHANNEL_NUM);
width = width1;
height = height1;
printf("Image size: %u\n", imageSize);
printf("Image width: %u\n", width);
printf("Image height: %u\n", height);
//memcpy(h_devicePixels, h_pixels, imageSize);
/************************** Start host processing ************************/
unsigned long long cputime = dtime_usec(0);
// cpu code here.....
cputime = dtime_usec(cputime);
stbi_write_png("host_output.png", width, height, CHANNEL_NUM, h_resultPixels, width*CHANNEL_NUM);
/************************** End host processing **************************/
/************************** Start device processing **********************/
// allocate memory on the GPU for the output image
cudaMalloc((void**)&d_pixels, imageSize);
cudaMalloc((void**)&d_resultPixels, imageSize);
cudaMemcpy(d_pixels, h_pixels, imageSize, cudaMemcpyHostToDevice);
checkCUDAError("CUDA memcpy to device");
dim3 blocksPerGrid(IMW / 16, 1);
dim3 threadsPerBlock(16, 1);
unsigned long long gputime = dtime_usec(0);
for (nBlurDegree = 0; nBlurDegree < BLUR_DEGREE; nBlurDegree++)
{
cudaMemset(d_resultPixels, 0, imageSize);
blurKernel << <blocksPerGrid, threadsPerBlock >> >(d_pixels, d_resultPixels, width, height);
cudaMemcpy(d_pixels, d_resultPixels, imageSize, cudaMemcpyDeviceToDevice);
cudaThreadSynchronize();
}
cudaDeviceSynchronize();
gputime = dtime_usec(gputime);
cudaMemcpy(h_devicePixels, d_resultPixels, imageSize, cudaMemcpyDeviceToHost);
printf("GPU time: %f seconds, CPU time: %f seconds\n", gputime/(float)USECPSEC, cputime/(float)USECPSEC);
printf("Speedup: %f\n", (cputime/(float)USECPSEC)/(gputime/(float)USECPSEC));
validate(h_pixels, h_devicePixels, imageSize);
stbi_write_png("device_output.png", width, height, CHANNEL_NUM, h_devicePixels, width*CHANNEL_NUM);
/************************** End device processing ************************/
// Release resources
cudaFree(d_pixels);
cudaFree(d_resultPixels);
//stbi_image_free(h2_pixels);
free(h_devicePixels);
free(h_pixels);
free(h_resultPixels);
return 0;
} // End main
I need help on how to get the GPU output image "device_output.png".