GPU CUDA internal thread scheduling not working properly - cuda

Question

Have been trying to make the following code work
__global__ void kernel(){
if (threadIdx.x == 1){
while(var == 0){
}
}
if (threadIdx.x == 0){
var = 1;
}
}
where var is a global device variable. I am simply launching
two threads in the same block using kernel<<<1,2>>>();
If I switch the order of the ifs the code terminates. However,
if I do not switch the order of the ifs the code does not terminate.
It almost seems like if one thread goes into infinite loop then
no other thread will be allocated run-time before that thread
ends all of its code.
I was under the impression that in a GPU all threads get some run-time
allocated to them (although the order might be unknown to us).
I have also tried putting __threadfence() inside the while loop and inside
the ifs statements and also tried putting some
printf inside the while loop. It still doesn't work.
What is going on ? Any feedback would be appreciated.
Thanks !

Answer 1

If var is some sort of global variable what you see makes perfect sense when you consider how instructions from threads are scheduled.
You need to walk through your code as you are a warp of threads (32 threads). Divergence is when some of those 32 threads executes some code, while the others do not. When divergence happens, only the threads that are running the same instruction actually run until the other threads catch back up.
In other words...
__global__ void kernel(){
//Both threads encounter this at the same time. Thread 0 is set on "hold" while thread 1 continues in the if block.
if (threadIdx.x == 1){
while(var == 0){
}//infinite loop, Thread 0 will always be on hold. Thread 1 will always be in this loop
}
if (threadIdx.x == 0){
var = 1;
}
}
as opposed to...
__global__ void kernel(){
//Both threads encounter this at the same time. Thread 1 is set on "hold" while thread 0 continues in the if block.
if (threadIdx.x == 0){
//thread 1 sets global variable var to 1
var = 1;
}
//Threads 1 and 0 join again.
//Both encounter this. Thread 0 is set on hold while thread 1 continues.
if (threadIdx.x == 1){
//var was set to 1, this is ignored.
while(var == 0){
}
}
//Both threads join
}
Revisit the programming guide and review warps. If you want to test this further, try putting both threads in two blocks, this will prevent them from being in the same warp.
Be forewarned though that CUDA in general does not guarantee thread execution order between warps and blocks (unless synchronization of some method is used __syncthreads() or exiting a kernel).