Error C3561: tile barrier operation...occurring in debug mode only

Question

Hi, 
I am new in C++ AMP, please, help me figure out why my code compile in Release mode, but C3561 occurring in debug mode.
At first, short version to demonstrate compile errors
parallel_for_each(D.extent.tile<TILE_SIZE>(), [=](concurrency::tiled_index<TILE_SIZE> t_idx) restrict(amp)
float threshold = P[t_idx.global];
tile_static float my_tile[TILE_SIZE];
tile_static int calculatedCount;
for (int stride=0; calculatedCount < TILE_SIZE; stride++)
my_tile[t_idx.local[0]] = P[t_idx.global[0] + stride*TILE_SIZE];
t_idx.barrier.wait();
for (int i =0; i < TILE_SIZE; i++)
if (my_tile[i] >= threshold)
D[t_idx.global] = 0;
calculatedCount++;
Short version does not compile in debug and release mode. Occurring very strange "tile barrier error" C3561.
However, full version shows more interesting results: compile errors only in debug mode, 
parallel_for_each(D.extent.tile<TILE_SIZE>(), [=](concurrency::tiled_index<TILE_SIZE> t_idx) restrict(amp)
float threshold = P[t_idx.global] + tp;
float maxDrawdown = 0;
float open = P[t_idx.global];
tile_static float my_tile[TILE_SIZE];
tile_static int calculatedCount;
int stride = 0;
bool calculated = false;
calculatedCount = 0;
t_idx.barrier.wait();
for (; calculatedCount < TILE_SIZE; stride++)
if (t_idx.global[0] + stride*TILE_SIZE < sz)
my_tile[t_idx.local[0]] = P[t_idx.global + stride*TILE_SIZE];
t_idx.barrier.wait();
if (calculated)
continue;
for (int i = stride == 0 ? t_idx.local[0] : 0; i < TILE_SIZE; i++)
if (maxDrawdown < open - my_tile[i])
maxDrawdown = open - my_tile[i];
if (my_tile[i] >= threshold)
duration[t_idx.global] = stride*TILE_SIZE + i - t_idx.local[0];
D[t_idx.global] = maxDrawdown;
calculated = true;
calculatedCount++;
break;
if (stride*TILE_SIZE + i >= sz)
calculated = true;
calculatedCount++;
D[t_idx.global] = maxDrawdown;
duration[t_idx.global] = 0;
break;

Answer 1

Hello, thank you for your inquiry. The issue here is that you have a race condition and control flow that is conditional on the variable that's subject to the race. To be precise, in the simplified example, the following:
calculatedCount++;
has the effect that every lane tries to increment calculatedCount. Since there are no guarantees about ordering or completion with the given code, the compiler (reasonably) fears that this might result in a case where some lanes break out of the loop while
others do not (different calculatedCount values per lane). This is invalid due to the fact that the body of the loop contains a barrier (all lanes must see a barrier i.e. control flow must not diverge around it). Hence the odd error. The solution here
could be to use an atomic increment on calculatedCount and add a barrier after the innermost loop, so that the outermost loop is tile-synchronous, like so:
for (int stride=0; calculatedCount < TILE_SIZE; stride++) {
my_tile[t_idx.local[0]] = P[t_idx.global[0] + stride*TILE_SIZE];
t_idx.barrier.wait();
for (int i =0; i < TILE_SIZE; i++) {
if (my_tile[i] >= threshold) {
D[t_idx.global] = 0;
concurrency::atomic_fetch_inc(&calculatedCount);
t_idx.barrier.wait();
Also, as a curiosity, what is the intent of the innermost loop? My reading of it suggests that it is in error i.e. each value that you cache ends up being processed multiple times: all lanes process [0], then [1], then [2] etc. If [0] is above the threshold,
this means that you end the loop after processing just that one datum. Since I presume you want to process the data in my_tile, the way to achieve that is to remove the for and leave the body modified like so:
for (int stride=0; calculatedCount < TILE_SIZE; stride++) {
my_tile[t_idx.local[0]] = P[t_idx.global[0] + stride*TILE_SIZE];
t_idx.barrier.wait();
if (my_tile[i] >= threshold) {
D[t_idx.global] = 0;
concurrency::atomic_fetch_inc(&calculatedCount);
t_idx.barrier.wait();
Hope this helps! Cheers!