Rule 8.22

A kernel function is an exported function that is not an entry point and takes at least one array with no size (array<T>); its candidate loops are the for and for…of statements at the top level of its body, and no other loop is ever a candidate. Its body is scalar statements, then its loops, then an optional return of scalars; a statement outside its loops that writes an array, or that is neither a loop nor a scalar statement, runs the whole function on the CPU, and so does a loop that reads a variable an earlier loop reduces (“split the function”). A candidate loop runs as a GPU kernel only when this proof accepts it, on the IR, with no solver and no alias analysis:

• R1: the loop is counted (Rule 7.5) with an additive constant step; a while and a multiplicative step are refused.
• R2: no return inside it, and no break that belongs to it (one inside a nested loop or switch belongs to that).
• R3: every write (an assignment, an inout argument, an atomic, a textureStore) lands on a name declared in the body; on an outer array at a*i + c (a a nonzero constant, the same at every write to that array, with each c in [0, |a|) or one c), at one index whose coefficient of i is loop-invariant, or at i*W + x over a nested loop of x from 0 to < W; on a texture at vec2(i % W, i / W); on a reduction variable written only as s op= e, s = s op e, s = min(s, e) or s = max(s, e) with one op of + * & | ^ min max and e not reading s; or on an integer array written only as a[k] op= e, a scatter reduction.
• R4: an array the loop writes is read in the body only at an index it writes, a reduction variable is not read, and the value an atomic returns is not read.
• R5: a function the body calls, transitively, writes no module variable and no binding.
• R6: no barrier, no workgroup memory and no console call in the body or in what it calls.

A loop the proof refuses runs on the CPU, and the program is correct either way: the refusal is a warning, TS8070, on the loop, whose first sentence names the line and the author’s own names and whose second gives the remedy, one per loop for the first reason (Rule 12.4). A variable an accepted loop reduces is combined in the tree order on every tier (Rule 7.2): each iteration combines into it from the operator’s identity, the iterations’ values are folded 256 at a time by the workgroup tree (at stride 128, then 64, down to 1, slot t becomes slot[t] op slot[t + s], the last block padded with the identity), the partials the same way until one is left, and the variable is combined with that last; a loop that runs no iteration leaves it as it was.