Unexpected output from CUDA program - reference

Question

I am having a problem with the code in CUDA. The code compiles properly but it gives an unexpected output when the program runs completely.
In this case, step is supposed to increase until stepcount is reached. However, only one step is outputted. What exactly did I do wrong?
Also, how do I make reference to a particular xcord, ycord or zcord. E.g. using arrays in CPU code I can refer to a particular element by xcord[1]. In CUDA's case, do I use xcord[threadidx.x]?
#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
/* Kernal code */
__global__
void run(float *lvelox, float *lveloy, float *lveloz, float *xcord, float *ycord, float *zcord)
{
lveloy[threadIdx.x] = lveloy[threadIdx.x] - 9.81;
xcord[threadIdx.x] = xcord[threadIdx.x] + lvelox[threadIdx.x];
ycord[threadIdx.x] = ycord[threadIdx.x] + lveloy[threadIdx.x];
zcord[threadIdx.x] = zcord[threadIdx.x] + lveloz[threadIdx.x];
}
/* Host code */
int main(void) {
FILE *ofp;
char *mode = "r";
char outputFilename[] = "Output.txt";
float dlvelox;
float dlveloy;
float dlveloz;
float lvelox[1000] = {};
float lveloy[1000] = {};
float lveloz[1000] = {};
float xcord[1000] = {};
float ycord[1000] = {};
float zcord[1000] = {};
int fp;
int id;
int stepcount;
int step = 0;
{
ofp = fopen(outputFilename, "w");
if (ofp == NULL) {
fprintf(stderr, "Can't open output file %s!\n", outputFilename);
exit(1);
}
/* Obtaining velocity */
{
printf("Enter the initial horizontal velocity of the balls:\n");
scanf("%f", &dlvelox);
fprintf(ofp, "Initial horizontal velocity: %f\n", dlvelox);
printf("Enter the initial vertical velocity of the balls:\n");
scanf("%f", &dlveloy);
fprintf(ofp, "Initial vertical velocity: %f\n", dlveloy);
printf("Enter the initial Z velocity of the balls:\n");
scanf("%f", &dlveloz);
fprintf(ofp, "Initial Z velocity: %f\n", dlveloz);
}
for (int i = 0; i < 1000; i++)
lvelox[i] = dlvelox;
for (int i = 0; i < 1000; i++)
lveloy[i] = dlveloy;
for (int i = 0; i < 1000; i++)
lveloz[i] = dlveloz;
/* Obtain number of steps */
{
printf("Enter the number of steps wanted:\n");
scanf("%d", &stepcount);
fprintf(ofp, "Number of steps: %d\n", stepcount);
}
/* Initial console display */
{
fprintf(ofp, "\n");
fprintf(ofp, "X-cord, Y-cord, Z-cord, Horizontal Velo, Vertical Velo, Z Velo, Ball ID, Step\n");
fprintf(ofp, "\n");
}
/* GPU setup */
float *lveloxd;
float *lveloyd;
float *lvelozd;
float *xcordd;
float *ycordd;
float *zcordd;
int *stepd;
const int fsize = 1000*sizeof(float);
const int isize = 1000*sizeof(int);
/* Loop method */
while ( step < stepcount )
{
/* Memory allocation and copying to GPU */
cudaMalloc( (void**)&lveloxd, fsize );
cudaMalloc( (void**)&lveloyd, fsize );
cudaMalloc( (void**)&lvelozd, fsize );
cudaMalloc( (void**)&xcordd, fsize );
cudaMalloc( (void**)&ycordd, fsize );
cudaMalloc( (void**)&zcordd, fsize );
cudaMemcpy( lveloxd, lvelox, fsize, cudaMemcpyHostToDevice );
cudaMemcpy( lveloyd, lveloy, fsize, cudaMemcpyHostToDevice );
cudaMemcpy( lvelozd, lveloz, fsize, cudaMemcpyHostToDevice );
cudaMemcpy( xcordd, xcord, fsize, cudaMemcpyHostToDevice );
cudaMemcpy( ycordd, ycord, fsize, cudaMemcpyHostToDevice );
cudaMemcpy( zcordd, zcord, fsize, cudaMemcpyHostToDevice );
/* Perform ACTUAL LOOP */
dim3 dimBlock( 1000 );
dim3 dimGrid ( 1 );
run<<<dimGrid, dimBlock>>>(lveloxd, lveloyd, lvelozd, xcordd, ycordd, zcordd);
/* Copy back the data */
cudaMemcpy( lvelox, lveloxd, fsize, cudaMemcpyDeviceToHost );
cudaMemcpy( lveloy, lveloyd, fsize, cudaMemcpyDeviceToHost );
cudaMemcpy( lveloz, lvelozd, fsize, cudaMemcpyDeviceToHost );
cudaMemcpy( xcord, xcordd, fsize, cudaMemcpyDeviceToHost );
cudaMemcpy( ycord, ycordd, fsize, cudaMemcpyDeviceToHost );
cudaMemcpy( zcord, zcordd, fsize, cudaMemcpyDeviceToHost );
cudaFree( lveloxd );
cudaFree( lveloyd );
cudaFree( lvelozd );
cudaFree( xcordd );
cudaFree( ycordd );
cudaFree( zcordd );
fprintf(ofp, "%f, %f, %f, %f, %f, %f, %d\n", xcord, ycord, zcord, lvelox, lveloy, lveloz, step);
step = step + 1;
if ( step == stepcount )
{
return 0;
}
}
fclose(ofp);
}
}

Answer 1

The probable answer is the following if it is due to SEGFAULT in the kernel:
You are allocating arrays of 1000 entities, and launching one block of 1000 threads. Due to cuda having a granularity of 32 threads (warpsize) and you want 1000 threads, 1024 threads will be launched as ceil(1000/32) = 32 warps = 1024 threads.
Now as you only have arrays of 1000 elements, the 24 threads you did not request but was spawned, will access outside allocated memory resulting in a SEGFAULT, i.e. lveloy[threadIdx.x] where threadIdx.x = 1000-1023.
To prevent that, just enclose as such:
if(threadIdx.x < 1000) {
lveloy[threadIdx.x] = lveloy[threadIdx.x] - 9.81;
xcord[threadIdx.x] = xcord[threadIdx.x] + lvelox[threadIdx.x];
ycord[threadIdx.x] = ycord[threadIdx.x] + lveloy[threadIdx.x];
zcord[threadIdx.x] = zcord[threadIdx.x] + lveloz[threadIdx.x];
}
Also, how do I make reference to a particular xcord, ycord or zcord.
E.g. using arrays in CPU code I can refer to a particular element by
xcord[1]. In CUDA's case, do I use xcord[threadidx.x]?
You can access it just as you would on the CPU, either through literals xcord[1] or dependent on the thread xcord[threadidx.x] or both as xcord[threadidx.x+1] (not recommended due to non coalesced memory )