The topic of this page is to determine whether or not a Loop
can be run in parallel. This is determined by looking at the
structure of the loop and figuring out what the data dependancies
are, and whether they will allow the compiler to Unroll the loop.
The primary data dependancies we need to look at are between
two instructions INSIDE the loop, and between two instructions
accross iterations, or an inter-iteration dependance.
The first dependance will not cause a problem for unrolling,
save that the instructions must be kept in the same order, when
the loop is unrolled. The second dependance may or maynot cause
the loop to be Non-Parallel. If the a statement requires a value
it produces in a previous iteration, then thatstatement is said
to have a Circular Dependance. The occurance of a Circular
Dependance, means the loop cannot be made Parallel.
Just because a loop has an inter-iteration dependance does not
mean that the loop cannot be unrolled, as long as the dependance
is NOT Circualr, than it can. The only thing that is neccessary
is that the inter-iteration dependance needs to be removed by
moving peices of the code around.
Can the following Loop be made Parallel?
A[i+1] = A[i] + C[i]; /*S1*/
B[i+1] = B[i] + A[i+1]; /*S2*/
To find the solution, we first need to look at the dependancies.
Inside one iteration:
S2 is dependant on S1 for the value of A[i+1].
S1 depends on S1 for
the value of A[i] computed in iteration i-1.
S2 depends on S2 for
the value of B[i] computed in iteration i-1.
Note that S1 depends on S1, and S2 depends on S2 inbetween loop
iterations. This is the RED flag we discussed earlier. Because
the loop containscircular data dependancies, this loop can not
Lets look at another loop.
A[i] = A[i] + B[i]; /*S1*/
B[i+1] = C[i] + D[i]; /*S2/
First start at the dependancies inside one interation of the loop. The
only dependance inside the loop is A[i] as a destination and source, but
this is not really an issue.
Ok, since that is not an issue, lets take a look at the dependancies
B[i+1] is computed, so for iteration i, S1 depends on S2 in iteration i-1.
Since no line contains a circular dependance, the loop can be unrolled.
However, it will need a little arranging to remove the one dependance that
is still there.
Since S1 does not depend on S2, the instructions do not need to be
executed in the order that they are above. This is important to note, since
we want to remove the inter-iteration dependance. To remove this dependance
we need to shift the loop a little.
If we execute S2 for iteration i, then S1 for iteration i+1 as the
loop. Doing this will cause S1 to be 'missed' on the first iteration, so
to fix that, we will need to run it once before entering the loop, with an
index of 1. In effect this executes half of the first iteration of the loop
and so we need to run S2 once the loop is complete to finish the other half
of it. (Remember here that we are actually executing half of each iteration
in our new loop) With those modifications the loop now looks like this:
A = A + B;
B[i+1] = C[i] +D[i];
A[i+1] = A[i+1] + B[i+1];
B = C + D;
This loop can be unrolled, and then run multiple iterations with fewer
branches, which, of course, eliminates stalls.
A quick summary of the material presented here:
If there is a circular dependance in between loop iterations, Loop can not
be unrolled. End of discussion.
If there are dependancies inbetween too iterations, but they are not
circular, you may be able to rewrite the code so that the dependancies
are located in a inside a single iteration, and then the loop can be
unrolled. If you can not rewrite the loop to remove the inter-iteration
dependancies then the loop is not parrallel.
If there are no data dependancies, then the loop can be unrolled, as it