Active wait on previous block without atomicAdd(x,0) - cuda

Question

I have a CUDA kernel where a blocks requires every previous blocks to be finished before the new block can be executed. I achieve this synchronization with two atomic counters like this:
__global__
static void waitTest(int* counters)
{
__shared__ int orderedBlockId;
int tid = threadIdx.x;
if(tid == 0){
orderedBlockId = atomicAdd(&counters[0], 1 );
//wait on previous group of 16 blocks
int expectedCounter = orderedBlockId / 16 * 16;
while(atomicAdd(&counters[1],0) < expectedCounter){
//wait
}
}
__syncthreads();
//do something
__syncthreads();
if(tid == 0){
atomicAdd( &counters[1], 1 );
}
}
int main(){
thrust::device_vector<int> counters(2,0);
waitTest<<<128,128>>>(thrust::raw_pointer_cast(counters.data()));
}
My question:
Is there a cheaper way of forcing a global memory read instead of atomicAdd(&counters[1],0)?
Replacing it just with counters[1] time-outs the kernel.

Answer 1

As Robert mentioned in the comments the counters have to be declared as volatile. In order to pass them to atomicAdd the counters have to be cast back to their original types (without volatile). Code:
__global__
static void waitTest(volatile int* counters)
{
__shared__ int orderedBlockId;
int tid = threadIdx.x;
if(tid == 0){
orderedBlockId = atomicAdd( (int*) &counters[0], 1 );
//wait on previous group of 16 blocks
int expectedCounter = orderedBlockId / 16 * 16;
while(counters[1] < expectedCounter){
//wait
}
}
__syncthreads();
//do something
__syncthreads();
if(tid == 0){
atomicAdd( (int*) &counters[1], 1 );
}
}