Simple CUDA code giving unexpected output - cuda

Question

I've a simple CUDA kernel which is incrementing the value of an int by 1 and changing a bool from true to false. Here's my code.
#include <stdio.h>
__global__ void cube(int* d_var, bool* d_bool){
int idx = threadIdx.x;
//do basically nothing
__syncthreads();
*d_var = *d_var + 1;
*d_bool = false;
}
int main(int argc, char** argv){
int h_var = 1;
int* d_var;
bool h_bool = true;
bool* d_bool;
cudaMalloc((void**)&d_var, sizeof(int));
cudaMalloc((void**)&d_bool, sizeof(bool));
while(h_var < 10){
h_bool = true;
//printf("%d\n", h_bool);
//printf("%d\n", h_var);
cudaMemcpy(d_var, &h_var, sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_bool, &h_bool, sizeof(bool), cudaMemcpyHostToDevice);
cube<<<10, 512>>>(d_var, d_bool);
cudaThreadSynchronize();
cudaMemcpy(&h_var, d_var, sizeof(int), cudaMemcpyDeviceToHost);
cudaMemcpy(&h_bool, d_bool, sizeof(bool), cudaMemcpyDeviceToHost);
printf("%d\n", h_var);
printf("%d\n", h_bool);
}
cudaFree(d_var);
cudaFree(d_bool);
//cudaFree(d_out);
return 0;
}
The problem is instead of 1 the output shows an increment of 2 in each step. Thus the output is
1
3
5
7
11
Could someone help me understand what's happening here.

Answer 1

You have a race condition. All threads in the grid associated with the kernel launch are attempting to update the same location (d_var). You'll have to properly manage this access or else you will have unpredictable results.
To understand the race condition better, you need to realize that an operation like this:
*d_var = *d_var + 1;
is performed in multiple steps by the machine. When multiple threads are each asynchronously executing those multiple steps on the same location, the results are unpredictable. One thread can overwrite what another thread has just written, and the results will not be consistent.
__syncthreads() doesn't do anything to manage multiple threads accessing the same location, and furthermore __syncthreads only operates on the threads within a block, not all of the threads in a grid.
One possible approach to manage the simultaneous access is to use atomics. Atomics will force an orderly access to a memory location by multiple threads that are attempting to do so at the same time.
You could modify your kernel like this:
__global__ void cube(int* d_var, bool* d_bool){
int idx = threadIdx.x;
//do basically nothing
__syncthreads();
atomicAdd(d_var, 1); // modify this line
*d_bool = false;
}
This will now result in d_var getting updated once per thread, for each kernel launch. So if you launch a single thread (<<<1,1>>>), your variable should increase by one per kernel launch. If you launch 5120 threads (<<<10,512>>>), then your variable should increase by 5120 per kernel launch.
Note that we don't need to worry about d_bool in this case, because the only possible outcome is that it is set to false, and that is guaranteed in this case even if multiple threads are doing it.
If you only want to increment the variable by 1 per kernel launch, no matter how many threads are in the grid, then you could modify your kernel code to condition that update on only a single thread:
__global__ void cube(int* d_var, bool* d_bool){
int idx = threadIdx.x + blockDim.x*blockIdx.x; // create globally unique thread ID
//do basically nothing
__syncthreads();
if (idx == 0) // only thread 0 does the update
*d_var = *d_var + 1;
*d_bool = false; // all threads will do this
}
With that modification, I get what I consider to be expected results:
$ cat t997.cu
#include <stdio.h>
__global__ void cube(int* d_var, bool* d_bool){
int idx = threadIdx.x + blockDim.x*blockIdx.x;
//do basically nothing
__syncthreads();
if (idx == 0)
*d_var = *d_var + 1;
*d_bool = false;
}
int main(int argc, char** argv){
int h_var = 1;
int* d_var;
bool h_bool = true;
bool* d_bool;
cudaMalloc((void**)&d_var, sizeof(int));
cudaMalloc((void**)&d_bool, sizeof(bool));
while(h_var < 10){
h_bool = true;
//printf("%d\n", h_bool);
//printf("%d\n", h_var);
cudaMemcpy(d_var, &h_var, sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_bool, &h_bool, sizeof(bool), cudaMemcpyHostToDevice);
cube<<<10, 512>>>(d_var, d_bool);
cudaThreadSynchronize();
cudaMemcpy(&h_var, d_var, sizeof(int), cudaMemcpyDeviceToHost);
cudaMemcpy(&h_bool, d_bool, sizeof(bool), cudaMemcpyDeviceToHost);
printf("%d\n", h_var);
printf("%d\n", h_bool);
}
cudaFree(d_var);
cudaFree(d_bool);
//cudaFree(d_out);
return 0;
}
$ nvcc -o t997 t997.cu
$ ./t997
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
$
The zeros are in there because your code is printing out the h_bool variable, and the printout starts at 2 rather 1 because your first printout is after the kernel has been executed.