the driver folks made a change that caused one of our internal tests, inigo quilez's "leizex" demo, to hang a very old model of GPU.

the catch is, the change should have been a complete no-op: they *literally did nothing but remove a bit of dead code* before passing it to the compiler.

we looked into it. it turns out the presence of the dead code slightly peturbed the decisions made by the reassociation pass. but the differences were fine and correct, just slightly different placements of instructions and so on. and it worked correctly on all *other* GPUs with the same input code, despite those differences. just not this one.

a coworker sobbed into his monitor as and did a whole bunch of debugging, made harder by the GPU's comparative age and lack of more modern debugging features. eventually he concluded, with fairly high certainty, that the core loop of the shader was infinite-looping.

but why? it looked like this (pseudocode):

for (t = 0.1f; t < 5.f; )  {
	pos = ro + (t * rd);
    /* ... */
	/* lots of code omitted that performs a raymarching step and calculates a new step size, 'h' */
    /* ... */
	if (h < 0.001f) break;
	t += h * 0.12f;
}

even considering floating point numerics and "fast-math" optimizations, this should not be possible. the code is not numerically sensitive, and the code transformations appeared correct.

we confirmed that the loop was hanging by adding another variable:

int foo = 0;
for (t = 0.1f; t < 5.f; )  {
	pos = ro + (t * rd);
	/* ... */
	if (h < 0.001f) break;
	t += h * 0.12f;
    if (foo++ > 1000000) break;
}

which stopped the hang after some waiting time. yet this should be quite impossible.

let's dig deeper.

	if (h < 0.001f) break;
	t += h * 0.12f;

this ends up looking like this after control flow flattening and considering the for loop's exit condition:

t = h < 0.001f ? t : t + h * 0.12f;
if (h < 0.001f || !(t < 5.f)) break;

this is still reasonable. but note: the comparison occurs twice. furthermore, as a side note, this GPU is VLIW and eagerly duplicates operations when it can in order to make more clever use of space in its instruction "bundles". and then it can do the operations themselves in different ways.

t = (h - 0.001f < 0) ? t : t + h * 0.12f;
if (h < 0.001f || !(t < 5.f)) break;

h itself was a multiply (let's call it a*b).

t = (a * b - 0.001f < 0) ? t : t + a * b * 0.12f;
if (a * b < 0.001f || !(t < 5.f)) break;

now we form FMAs.

t = (FMA(a, b, -0.001f) < 0) ? t : FMA(a * b, 0.12f, t);
if (a * b < 0.001f || !(t < 5.f)) break;

now one can come up with values of a and b that result in the first condition being true ("do not update t") and the first condition being false ("don't break").

for a few pixels in the frame, the shader infinite loops, and the GPU hangs.

we cry.



oh and it didn't break before because the multiply was in a different block of the shader so it wasn't able to be "clever".