The document discusses techniques for eliminating dependent computations to increase parallelism in code. These include loop unrolling, back substitution, copy propagation, tree-height reduction, and rewriting recurrences with fewer dependent operations through unrolling. Loop unrolling reduces dependencies by increasing the distance between operations. Back substitution and copy propagation eliminate redundant computations. Tree-height reduction restructures operations to reduce the number of execution cycles needed. Rewriting recurrences sums operations that were previously dependent. Together these techniques aim to remove dependencies limiting parallel execution.

1. Detecting and enhancing loop
level parallelism
With large dependence distance,
more potential of parallelism is
obtained by loop unrolling.
Longer distances may provide the
enough parallelism to keep the
processor busy.
docsity.com

2. Back Substitution
Back Substitution increases the
amount of parallelism, but sometimes it
also increases the amount of
computation required
These techniques can be applied both:
- within a basic block; and
- within a loop
docsity.com

3. Eliminating dependent computations
Within a basic block:
Here, algebraic simplifications of
expressions and an optimization
is used.
This called copy propagation
It eliminates operations that copy
values
docsity.com

4. Eliminating dependent computations
For example; copy propagation of
DADDUI R1,R2,#4
DADDUI R1,R1,#4
Results into
DADDUI R1,R2,#8
Here, computations are eliminated to
remove dependence
docsity.com

5. Eliminating dependent computations
Optimization:
Tree-Height Reduction Technique
It is also possible to increase the
parallelism of the code by
possibly increasing the number of
operations.
Such optimization is called tree
height reduction
docsity.com

6. Eliminating dependent computations
For example, the code sequence
ADD R1,R2,R3
ADD R4,R1,R6
ADD R8,R1,R7
requires three cycles for execution
Because, here all the instructions depend
on immediate predecessor and cannot be
issued in parallel
docsity.com

7. Eliminating dependent computations
Now taking the advantage of the
associatively, the code can be transformed
and written in the from shown as below,
ADD R1,R2,R3
ADD R4,R6,R7
ADD R8,R1,R4
This sequence can be computed in two
execution cycles by issuing first 2
instruction in parallel
docsity.com

8. Eliminating dependent computations
Recurrences are expressions
whose value in one iteration is
given by a function that depends
on the previous iteration.
Common type of recurrence occurs
in:
sum = sum + x;
docsity.com

9. Eliminating dependent
computations
Assuming an unroll loop with the
recurrence of five times.
If the value of x of these five
iterations be given by x1, x2, x3,
x4 and x5.
Then we can write the value of
sum at the end of each unroll as,
docsity.com

10. Eliminating dependent
computations
Sum = sum + x1 + x2 + x3 + x4 +
x5;
Unoptimizing the expressions
requires five dependent
operations.
And it can be rewritten as,
docsity.com

11. Eliminating dependent
computations
Sum = (( sum + x1) + ( x2 + x3)) + (
x4 + x5);
This can be evaluated in only three
dependent operations.
Recurrence also occurs from implicit
calculations.
With unrolling the dependent
computations can be minimised.
docsity.com