CUDA fails to run / copy memory - c++

Question

I am writing a program to do several copies of an integration in parallel to speed up its evaluation for say, 50000 different inputs.The code generally takes about 0.0005 sec to run on C++ on a single CPU core and its internal loops in my tests run for around 3000 cycles, so I think it may not be too complicated to run on a gpu thread. Also, I use Visual Studio 2013 and GTX 860m for writing my programs and do not have compiling other programs written in CUDA C.
here is my code: (you can get the data file from here ElCentro-import2.txt)
#include <stdio.h>
#include<iostream>
#include <math.h>
#include <fstream>
#include <cmath>
#include <cuda_runtime.h>
using namespace std;
__global__ void
vectorAdd(const float *A, const float *p, float *u, float *v, float *a, float *fs, float *rhat, float *phat, int j, int numElements)
{
int ni = blockDim.x * blockIdx.x + threadIdx.x;
int ti = 10000 * ni;
float t = A[ni];
float m = 1.0f;
float epsilon = 10.0f;
float gamma = 0.5f;
float beta = 1.0f / 4.0f;
float pi = 3.14159f;
float ksy = 0.04f;
float dt = 0.02f;
float fy = 1000.0f;
float c = 4.0f * ksy * pi / t;
float a1 = m / (beta * dt * dt) + gamma * c / (beta * dt);
float a2 = m / (beta * dt) + c*(gamma / beta - 1.0f);
float a3 = (1.0f / (2.0f *beta) - 1.0f)* m + dt*(gamma / (2.0f *beta) - 1.0f) *c;
float k = m * (2.0f*pi / t)*(2.0f*pi / t);
float fz;
float ab;
if (ni < numElements)
{
v[10000 * ni] = 0.0f;
u[10000 * ni] = 0.0f;
fs[10000 * ni] = 0.0f;
a[10000 * ni] = 0.0f;
for (size_t i = 0 + 10000 * ni; i < j-1 + 10000 * ni; i++)
{
u[i + 1] = u[i];
fs[i + 1] = fs[i];
phat[i + 1] = p[i + 1] + a1 * u[i] + a2*v[i] + a3*a[i];
rhat[i + 1] = phat[i + 1] - fs[i + 1] - a1 * u[i + 1];
ab = std::fabsf(rhat[i + 1]);
while (ab >= epsilon)
{
u[i + 1] = u[i + 1] + rhat[i + 1] / (k + a1);
fz = fs[i] + k*(u[i + 1] - u[i]);
if (fz > 0.0)
{
fs[i + 1] = fminf(fz, fy);
}
else
{
fs[i + 1] = fmaxf(fz, -fy);
}
rhat[i + 1] = phat[i + 1] - fs[i + 1] - a1 * u[i + 1];
ab = std::fabsf(rhat[i + 1]);
}
v[i + 1] = gamma*(u[i + 1] - u[i]) / beta / dt + (1.0f - gamma / beta)*v[i] + dt*(1.0f - gamma / 2.0f / beta)*a[i];
a[i + 1] = (u[i + 1] - u[i]) / beta / dt / dt - (1.0f / beta / dt)*v[i] + (1.0f - 1.0f / 2.0f / beta)*a[i];
}
}
}
int
main(void)
{
int numElements = 16;
int kore;
FILE* myfile;
size_t size = numElements * sizeof(float);
printf("[Vector addition of %d elements]\n", numElements);
float *h_data = (float *)malloc(10000);
float *h_datat = (float *)malloc(10000);
myfile = fopen("ElCentro-import2.txt", "r");
std::cout << "file is opened\n";
kore = 0;
while (EOF != fscanf(myfile, "%f %f \n", &h_datat[kore], &h_data[kore]))
{
kore++;
}
std::cout << kore << "file is read\n";
kore--;
size_t nsize = 10000 * numElements * sizeof(float);
float *h_A = (float *)malloc(size);
float *h_u = (float *)malloc(nsize);
float *h_v = (float *)malloc(nsize);
float *h_a = (float *)malloc(nsize);
float *h_p = (float *)malloc(nsize);
for (int i = 0; i < kore; ++i)
{
h_p[i] = -10000 * h_data[i];
}
for (int i = 0; i < numElements; ++i)
{
h_A[i] = 1.0f;
}
float *d_A = NULL;
err = cudaMalloc((void **)&d_A, size);
float *d_p = NULL;
err = cudaMalloc((void **)&d_p, nsize);
float *d_u = NULL;
err = cudaMalloc((void **)&d_u, nsize);
float *d_v = NULL;
err = cudaMalloc((void **)&d_v, nsize);
float *d_a = NULL;
err = cudaMalloc((void **)&d_a, nsize);
float *d_fs = NULL;
err = cudaMalloc((void **)&d_fs, nsize);
float *d_rhat = NULL;
err = cudaMalloc((void **)&d_rhat, nsize);
float *d_phat = NULL;
err = cudaMalloc((void **)&d_phat, nsize);
printf("Copy input data from the host memory to the CUDA device\n");
err = cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
err = cudaMemcpy(d_p, h_p, nsize, cudaMemcpyHostToDevice);
int threadsPerBlock = 1;
int blocksPerGrid = (numElements + threadsPerBlock - 1) / threadsPerBlock;
printf("CUDA kernel launch with %d blocks of %d threads\n", blocksPerGrid, threadsPerBlock);
vectorAdd <<<blocksPerGrid, threadsPerBlock >>>(d_A, d_p, d_u, d_v, d_a, d_fs, d_rhat, d_phat, kore-1, numElements);
err = cudaGetLastError();
cudaDeviceSynchronize();
printf("Copy output data from the CUDA device to the host memory\n");
err = cudaMemcpy(h_u, d_u, nsize, cudaMemcpyDeviceToHost);
}
for (int i = 0; i < numElements; ++i)
{
std::cout << h_u[1000+kore * i] << "\n";;
}
printf("Test PASSED\n");
err = cudaFree(d_A);
err = cudaFree(d_p);
err = cudaFree(d_u);
err = cudaFree(d_v);
err = cudaFree(d_a);
err = cudaFree(d_fs);
err = cudaFree(d_rhat);
err = cudaFree(d_phat);
free(h_A);
free(h_p);
free(h_u);
free(h_v);
free(h_a);
free(h_data);
free(h_datat);
err = cudaDeviceReset();
printf("Done\n");
return 0;
}
My problem is that when I try to copy the results from the device to host (say copy d_u to h_u) it genrates my error checking phrase:
Failed to copy vector u from device to host (error code uspecified launch failure)
Also, if i move the kernel sync code (cudaDeviceSynchronize()) to after the kernel call, it also generates an error report about kernel launch. I am quite new to C++ and CUDA programming and this problem has got me confused for several days.
This part should print the same value (~21.8) for several times (for numElements>1)
for (int i = 0; i < numElements; ++i)
{
std::cout << h_u[1000+kore * i] << "\n";;
}
UPDATE
if I set the value of numElements equal to 1, the code runs well, but this is not the point in parallel computing. I also cheked the GPU stats in GPU-Z and memory utilization is less than 1 MB and maximum GPU load is less than 1%. (Release Build)

Answer 1

I have changed the build from Debug to Release and the program runs well! Also by increasing the GPU time out setting in window registry (WDDM) this problem has got nearly eliminated.