Intel 9/12/051 Induction Variable Analysis with Chains of Recurrences Brief tutorial on induction...
-
Upload
poppy-underwood -
Category
Documents
-
view
214 -
download
0
Transcript of Intel 9/12/051 Induction Variable Analysis with Chains of Recurrences Brief tutorial on induction...
Intel 9/12/05 1
Induction Variable Analysis with Chains of Recurrences Brief tutorial on induction variable recognition
Past and present methods for IV detection
Chains of recurrences: why and how? Analyzing pointer arithmetic in loops Array dependence testing for loop restructuring
and vectorization Results and conclusions
Intel 9/12/05 2
Induction Variable Recognition: a Classic Compiler Problem
Detect induction variables (IVs) in loops
The example loop has a basic IV: a scalar integer variable with one unconditional update
Values of derived IVs depend on values of basic IVs
Loop analysis algorithms detect IVs by analyzing back edges to detect loops in IR forms, e.g. AST, CFG, or SSA
Beware of aliases!
I = 0do … I = I+1 …while (…)
…LDW R8,#0
…ADD R8,#1
…BNE L1
CFG
HLL
Intel 9/12/05 3
Most Loop Optimizations Rely on Accurate IV Recognition
Loop strength reduction [Allen69, Aho86]
IV elimination [Lowry69, Kennedy81, Aho86]
IV substitution [Gerlek95, Haghighat96, Wolfe92]
Loop iteration bounds analysis Pointer-to-array conversion and array recovery
[vanEngelen01b, Franke01] Array dependence testing for loop restructuring
[Banerjee88, Blume94, Goff91, Maydan91, Muchnick97, Psarris03, Pugh91, vanEngelen04, Wolfe92, Zima90] and others
Intel 9/12/05 4
A Classic Induction Variable Recognition Algorithm [Aho86]
Input: Loop L with reaching definition informationand loop-invariant information
Output: Triple (i,stride,init) for each IV
1. Find basic IVs: represent basic IV i by triple (i,stride,init)2. Find derived IVs: search for variables k with single assignment
k = j b where b is constant (loop invariant),if j has triple (i,c,d) and = * then k has triple (i,b*c, b*d)else if j has triple (i,c,d) and = + then k has triple (i,c, b+d)(assuming no use of k before its def)
Intel 9/12/05 5
IV Recognition for Loop Optimization
Example loop with IVs
IV Triples After strength reduction
After IV elimination
I = 0 J = 1 while (I<N) I = I+1 … = A[J] J = J+2 K = 2*I A[K] = … endwhile
(I,1,0) basic
(J,2,1) basic(I,2,2) derived
K = 0 I = 0 J = 1 while (I<N) I = I+1 … = A[J] J = J+2 K = K+2 A[K] = … endwhile
K = 0
while (K<2*N) … = A[K+1] K = K+2 A[K] = …endwhile
Intel 9/12/05 6
IV Recognition for Loop Vectorization & Parallelization
Example loop with IVs
After IV substitution (IVS) (note the affine indexes)
After parallelization
I = 0 J = 1 while (I<N) I = I+1 … = A[J] J = J+2 K = 2*I A[K] = … endwhile
for i=0 to N-1 S1: … = A[2*i+1] S2: A[2*i+2] = … endfor
forall (i=0,N-1) … = A[2*i+1] A[2*i+2] = … endforall
GCD test to solve dependence equation 2id - 2iu = -1Since 2 does not divide 1 there is no data dependence.
W R W R W R
A[2*i+1]
…
A[2*i+2]
A[]
Dep testIVS
Intel 9/12/05 7
IV Recognition isn’t Always Trivial … IVs that are linear (affine) but not handled by [Aho86]:
It quickly gets more complicated with deps and flow Note that transformations such as constant propagation,
forward substitution, and code motion can help
do K = J+1 J = K+1while (…)
do K = 3 K = K+J if (…) J = K else J = J+3 endifwhile (…)
Intel 9/12/05 8
More Powerful IV Recognition Methods
Linear IV recognition on SSA forms and FUD chains[Cytron91, Wolfe92]
Linear and nonlinear IV recognition withsymbolic differencing [Haghighat95]
Linear and nonlinear IV recognition withrecurrence system solvers [Gerlek95]
Linear and nonlinear IV recognition withchains of recurrences [vanEngelen01a]
Intel 9/12/05 9
A Method for Linear IV Recognition on FUD Chains
Similar algorithms by [Cytron91, Wolfe92]
Factored use-def (FUD) chains are similar to single static assignment (SSA) forms
Input: FUD chainsOutput: Triple (i,stride,init) for each IV
1. Build depth-first spanning tree of operations2. Start at -node in loop cycle to find basic IVs3. Find derived IVs from other -nodes not in a cycle
Intel 9/12/05 10
Example
I1 = 3M1 = 0do I2 = (I1,I3) J1 = (?,J3) K1 = (?,K2) L1 = (?,L2) M2 = (M1,M3) J2 = 3 I3 = I2+1 L2 = M2+1 M3 = L2+2 J3 = I3+J2
K2 = 2*J3
while (…)
I2 = (i,1,3) J1 = (i,1,7)L1 = (i,3,1) K1 = (i,2,14)M2 = (i,3,0)
Spanningtree
Intel 9/12/05 11
Symbolic Differencingdo x = x+z y = z+1 z = y+1while (…)
Iteration x y z
1 x+z diff z+1 diff z diff
2 x+2z+2 z+2 diff z+3 2 z+2 2
3 x+3z+6 z+4 2 z+5 2 z+4 2
Use abstract interpretation to evaluate loop iterations and construct symbolic difference table of the IV values.
x(i) = x0 + z0i + (i2-i) y(i) = z0 + 2i + 1 z(i) = z0 + 2i
From difference tables compute the characteristic functions describing the IV progressions.
Intel 9/12/05 12
Symbolic Differencing: Oops
for i=0 to n t = a a = b b = c+2*b-t+2 c = c+d d = d+iendfor
[vanEngelen01a] identified a serious problem with the differencing method for IVs involving cyclic recurrence relations.
The inferred closed-form function might be incorrect when it is assumed that the polynomial order of the IVs is bounded.
Quiz: guess the maximum polynomial order of the characteristic functions of the IVs shown in the loop on the right.
?
Intel 9/12/05 13
Outline
Brief tutorial on induction variable recognition Chains of recurrences: why and how?
Chains of recurrences preliminaries [Zima92, vanEngelen01a] Chains of recurrences for IV recognition, loop analysis, and
optimization [vanEngelen01a, vanEngelen01b, vanEngelen04]
Analyzing pointer arithmetic in loops Array dependence testing for loop restructuring and
vectorization Results and conclusions
Intel 9/12/05 14
Preliminaries
A chain of recurrences (CR) represents a polynomial or exponential function or mix evaluated over a unit-distance grid [Zima92]
Basic form: {init, , stride}
Iteration {init, , stride} f(i) = 2i+1 = {1,+,2} f(i) = 2i = {1,*,2}
i = 0 init 1 1
i = 1 init stride 3 2
i = 2 init stride stride 5 4
i = 3 init stride stride stride 7 8
Intel 9/12/05 15
Chains of Recurrences:General Formulation
The key idea is to represent a non-constant CR stride in CR form itself, thereby forming a chain of recurrences
Example: f(i) = i2 = {0, +, s(i-1)} with s(i) = {1, +, 2}
Iteration {init, , s(i-1)} s(i) = {1, +, 2} f(i) = {0, +, s(i-1)}
i = 0 init 1 0
i = 1 init s(0) 3 1
i = 2 init s(0) s(1) 5 4
i = 3 init s(0) s(1) s(2) 7 9
Intel 9/12/05 16
Primary Application of CRs: Loop Strength Reduction
Loop strength reduction is straight forward to implement with CR forms of real-valued and complex functions [Zima92]
Method: add each CR and its nested CR stride as IVs to the loop nest
Intel 9/12/05 17
Example
Suppose f(i) = a + b·i + c·i2 = {a, +, {b+c, +, 2c}} We have two IVs x and y:
f(i) = x = {x0, +, y} with x0 = as(i) = y = {y0, +, 2c} with y0 = b+c
Add x and y as IVs to loop for efficient function evaluation over unit-distance grid i = 0, …, n :
x = ay = b+cfor i=0 to n f[i] = x x = x+y y = y+2*cendfor
0
5
10
15
20
25
30
1 2 3 4 5 6 7 8 9 10
Iteration
s(i)
Intel 9/12/05 18
Loop Strength Reduction:Multi-dimensional Loops
Algorithm for 2-d case (n-d similar)1. Determine iteration order:
for i = 0 to n for j = 0 to m
2. Compute CR forms for j-loop first by treating i invariant within j-loop
3. Compute multivariate CR (MCR) forms for i-loop
Intel 9/12/05 19
Example
Suppose f(i,j) = i2 + i·j + 11. Create IV k for f(i,j) in j-loop:
f(i,j) = kj = {pi, +, ri}j with pi = i2 + 1 and ri = i
2. Create IVs for pi and ri in i-loop:pi = {p0, +, qi}i with p0 = 1qi = {q0, +, 2}i with q0 = 1ri = {r0, +, 1}i with r0 = 0
3. Add IVs k, p, q, and r to loops
p = 1q = 1r = 0for i = 0 to n k = p for j = 0 to m f[i,j] = k k = k+r endfor p = p+q q = q+2 r = r+1endfor
Intel 9/12/05 20
How to Obtain CR Forms for Strength Reduction: CR Algebra Algorithm to compute the CR form of a symbolic function f(i):
1. Replace i with {0,+,1} in the symbolic form of f2. Compute CR form using the CR algebra rewrite rules
(selected rules shown here):
Example: f(i) = c·(i+a) = c·({0, +, 1}+a) = c{a, +, 1} = {c·a, +, c}
{x, +, y} + c {x+c, +, y}
c{x, +, y} {c·x, +, c·y}
{x, +, y} + {u, +, v} {x+u, +, y+v}
{x, +, y} * {u, +, v} {x·u, +, y{u, +, v}+v{x, +, y}+y·v}
Intel 9/12/05 21
But What About IV Recognition?
The key idea of our approach: Scan the loop to detect IV updates Determine the CR form of the IV using the update
operation
In simple terms, the method looks for operations on IVs that can be represented as CR forms:
do J = J+I I = I+3 P = 2*P while (…)
J = {J0, +, I} J = {J0, +, {I0, +, 3}} I = {I0, +, 3} P = {P0, *, 2}
Intel 9/12/05 22
Compiler Algorithms for IV Recognition with CRs
IV recognition algorithms [vanEngelen01a, vanEngelen04] :1. Scan the loop in backward order to determine recurrence relations
of scalar variables in the loop2. Compute CR forms of recurrence relations3. “Solve” CR forms by computing closed-form characteristic functions
with the CR inverse rules
Note: GCC 4.x uses this algorithm first published in [vanEngelen01a] applied to loops in SSA form.GCC developers refer to CRs as “scalar evolutions” (without proper justification).
Intel 9/12/05 23
Algorithm 1: Find Recurrences
Input: Loop L with live variable informationOutput: Set S of recurrence relations of IVs
1. Start with set S = { v, v | v is live at loop header }2. Search L from bottom to top:
for each assignment v = x of expression x to scalar variable v update tuples u, y in S by replacing v in y with x
Loop L Step S = {H, H, I, I, J, J, K, K}
do M = 2 L = J-H J = L+M K = K+M*I I = I+1 while (…)
54321
S5 = {H, H, I, I+1, J, J-H+2, K, K+2*I}S4 = {H, H, I, I+1, J, J-H+M, K, K+M*I}S3 = {H, H, I, I+1, J, L+M, K, K+M*I}S2 = {H, H, I, I+1, J, J, K, K+M*I}S1 = {H, H, I, I+1, J, J, K, K}
Intel 9/12/05 24
Algorithm 2: Compute CR Forms
Input: Set S with recurrence relationsOutput: CR forms for IVs in S
1. For each relation v, x in S do:if x is of the form v then v = v0 (v is loop invariant) if x is of the form v + y then v = {v0, +, y}if x is of the form v * y then v = {v0, *, y}if x does not contain v then v = {v0, #, y} (v is wrap around)
2. Simplify the CR forms with the CR algebra rewrite rules
Recurrence relation in S CR form Simplified CR form
H, HI, I+1J, J-H+2K, K+2*I
H = H0
I = {I0, +, 1}
J = {J0, +, 2-H}
K = {K0, +, 2*I}
H = H0
I = {I0, +, 1}
J = {J0, +, 2-H0}
K = {K0, +, 2I0, +, 2}
Intel 9/12/05 25
Algorithm 3: Solve
Input: CR forms for IVsOutput: Closed-form solutions for IVs (when possible)
1. For each CR form of v apply the CR inverse algebra, assuming loop is normalized for i = 0, …, n
2. Certain “exotic” mixed non-polynomial and non-exponential CR forms may not have closed forms
Loop L Simplified CR form Closed form
do M = 2 L = J-H J = L+M K = K+M*I I = I+1 while (…)
J = {J0, +, 2-H0} K = {K0, +, 2I0, +, 2} I = {I0, +, 1}
for i = 0, …
J = J0 + (2-H0)*i K = K0 + i2 + (2I0-1)*i I = I0 + i
Intel 9/12/05 26
Example 1
Loop L Step S = {x, x, z, z} CR form Closed form
do x = x+z y = z+1 z = y+1 while (…)
321
S3 = {x, x+z, z, z+2}S2 = {x, x, z, z+2}S1 = {x, x, z, y+1}
x = {x0, +, z} z = {z0, +, 2}
x(i) = x0 + z0i + i2-i z(i) = z0+2i
Intel 9/12/05 27
Example 2
DO I=1,M DO J=1,I ij = ij+1 ijkl = ijkl+I-J+1 DO K=I+1,M DO L=1,K ijkl = ijkl+1 xijkl[ijkl]=xkl[L] ENDDO ENDDO ijkl = ijkl+ij+left ENDDOENDDO
TRFD code segmentfrom Perfect Benchmark
with IV updates
DO I=0,M-1 DO J=0,I DO K=0,M-I-2 DO L=0,I+K+1 tmp = ijkl+L+I*(K+(M+M*M+2*left+6)/4)+J*(left+(M+M*M)/2)+((I*I*M*M)+2*(K*K+3*K+I*I*(left+1))+M*I*I)/4+2 xijkl[tmp] = xkl[L+1] ENDDO ENDDO ENDDOENDDO
TRFD after aggressiveinduction variable substitution
IVS
Intel 9/12/05 28
Recognizing Mixed Functional Forms and Reductions
Loop L Simplified CR form Factorial
I = 1 do F = F*I I = I+1 while (…)
F = {F0, *, 1, +, 1} I = {1, +, 1}
F = F0 * i!
Loop L Simplified CR form Reduction
I = 0; S = 0 do S = S+A[I] I = I+2 while (…)
S = {0, +, A[{0, +, 2}]} I = {0, +, 2}
S = ∑ A[2i]
Intel 9/12/05 29
Outline
Brief tutorial on induction variable recognition Chains of recurrences: why and how? Analyzing pointer arithmetic in loops
Converting pointer references into array references to facilitate array dependence testing and loop restructuring
Array dependence testing for loop restructuring and vectorization
Results and conclusions
Intel 9/12/05 30
Converting Pointer References to Array References
Key observation: pointers with pointer arithmetic in loops often behave similar to IVs
Use IV recognition algorithms to detect pointer-based IVs
Convert pointer-based IVs to closed-form characteristic functions to obtain array references
Intel 9/12/05 31
Pointer Access Descriptions of Pointer and Array References
A pointer access description (PAD) [vanEngelen01b] is a CR form of a pointer or array reference in a loop nest
PADs are computed with the CR-based IV algorithms
Loop Code PAD Sequence
a[i] {a, +, 1} a[0],a[1],a[2],a[3]
a[2*i+1] {a+1, +, 2} a[1],a[3],a[5],a[7]
a[(i*i-i)/2] {a, +, 0, +, 1} a[0],a[0],a[1],a[3]
a[1<<i] {a+1, +, 1, *, 2} a[1],a[2],a[4],a[8]
p++ {a, +, 1} a[0],a[1],a[2],a[3]
p+=i {a, +, 0, +, 1} a[0],a[0],a[1],a[3]
short a[…], *p;int i;p = a;for(i=0;…;i++){
}
Intel 9/12/05 32
Example
f += 2;lsp += 2;for (i = 2; i <= 5; i++){ *f = f[-2]; for (j = 1; j < i; j++, f--) *f += f[-2]-2*(*lsp)*f[-1]; *f -= 2*(*lsp); f += i; lsp += 2;}
Lsp_az speech codec segmentfrom ETSI with pointer updates.
for (i = 0; i <= 3; i++){ f[i+2] = f[i]; for (j = 0; j <= i; j++) f[i-j+2] += f[i-j]- 2*lsp[2*i+2]*f[i-j+1]; f[1] -= 2*lsp[2*i+2];}
Lsp_az speech codec segmentafter pointer-to-array conversion.
Note that all array indexexpressions are affine.
Intel 9/12/05 33
Outline
Brief tutorial on induction variable recognition Chains of recurrences: why and how? Analyzing pointer arithmetic in loops Array dependence testing for loop restructuring and
vectorization CR-based dependence testing Solving linear (affine), nonlinear, and symbolic equations
Results and conclusions
Intel 9/12/05 34
Benefits of Array & Pointer Dependence Testing with CRs
Reduced complexity of testing Eliminates IV substitution phase Eliminates the need for pointer-to-array conversion for
dependence testing on pointer-based C code
Extended coverage Able to solve linear, nonlinear, and symbolic dependence
equations Possibility to augment existing tests, such as the extreme
value test and range test
Intel 9/12/05 35
CR Dependence Equations
Compute dependence equations in CR form for pointer and array accesses in loop nests directly without IV substitution or pointer-to-array conversion
Solve the equations by computing value ranges of the CR forms to determine solution intervals
If the solution space is empty, there is no dependence
Intel 9/12/05 36
Determining the Value Range of a CR Form on a Domain
Suppose x(i) = {x0, +, s(i-1)} for i = 0, …, n If s(i-1) > 0 then x(i) is monotonically increasing If s(i-1) < 0 then x(i) is monotonically decreasing
If a function is monotonic on its domain, then it is trivial to find its exact value range
Intel 9/12/05 37
Example
Determine the value range of x(i) = (i2-i)/2 for i = 0,…,10 Convert to CR form x(i) = {0, +, 0, +, 1} = {0, +, {0, +, 1}} Monotonically increasing, since {0, +, 1} = i > 0 for i = 0,…,10 Therefore, lower bound of x(i) is x(0) = 0 and upper bound is x(10)
= (102-10)/2 = 45
Classic interval analysis often gives conservative results For this example, interval analysis gives the range
([0,10]2-[0,10])/2 = ([0,100]+[-10,0])/2 = [-10,100]/2 = [-5,50]
Intel 9/12/05 38
Solving a Dependence Equation
float a[…], *p, *q; p = a; q = a+2*n; for (i=0; i<n; i++) { t = *p; S: *p++ = *q; *q-- = t; }
Dependence equation:{a, +, 1}id = {a+2n, + ,-1}iu
Constraints:0 < id < n-10 < iu < n-1
Rewrite dependence equation:{a, +, 1}id = {a+2n, +, -1}iu
{a, +, 1}id - {a+2n, +, -1}iu = 0 {{-2n, +, 1}iu, +, 1}id = 0
Compute solution interval:Low[{{-2n, +, 1}iu, +, 1}id]= Low[{-2n, +, 1}iu]= -2nUp[{{-2n, +, 1}iu, +, 1}id]= Up[{-2n, +, 1}iu + n-1]= Up[-2n + 2n - 2]= -2
No dependence
S *
p={a, +, 1}q={a+2n, +, -1}
Intel 9/12/05 39
Dependence Testing on Nonlinear & Symbolic Accesses
float a[…], *p, *q;p = q = a;for (i=0; i<n; i++){ for (j=0; j<=i; j++) *q += *++p; q++;}
CR dep. test disprovesflow dependence (<, <)
p = {{a+1, +, 1, +, 1}i, +, 1}j = a[(i2+i)/2+j+1]q = {a, +, 1}i = a[i]
DO i = 1, M+1 S1: A[I*N+10] = ... S2: ... = A[2*I+K] K = 2*K+N ENDDO
S1: A[{N+10, +, N}i]S2: A[{K0+2N, +, K0+ N+2, *, 2}i]
CR range test disprovesdependence when
K+N > 10 and K > 2
Intel 9/12/05 40
Some Observations wrt. Vectorization
Auto-vectorization (mostly) requires affine array accesses, e.g. to enable unimodular loop transformations
Best when vector loads/stores are memory aligned Data remapping possible, but runtime remapping may
outweigh vectorization speedup CR forms of array and pointer accesses naturally
represent memory access sequences, which may help in detecting aligned memory accesses and to support data remapping
Intel 9/12/05 41
Some Preliminary Results
Perfect Club Suite Benchmark
Additional dependence pairs broken by CR test over Omega and range test
DYFESM*
OCEAN
QCD*
BDNA
TRFD
MDG*
MG3D*
0
63
51
6
10
62
8
Results shown produced from CR test implementation in Polaris*Test results incomplete due to Polaris memory issue
Intel 9/12/05 42
Conclusions
The CR-based compiler analysis framework supports: IV recognition and strength reduction optimizations Pointer-to-array conversion for analysis of C loops Array dependence testing with affine, nonlinear, and symbolic
dependence equations Dependence testing on pointer arithmetic Induction variable substitution
Implementations GCC 4.x (with limitations!) From our lab: Polaris (TBA)
Intel 9/12/05 43
Further Reading Robert van Engelen, Johnnie Birch, Yixin Shou, Burt Walsh, and Kyle Gallivan, “A
Unified Framework for Nonlinear Dependence Testing and Symbolic Analysis”, in the proceedings of the ACM International Conference on Supercomputing (ICS), 2004, pages 106-115.
Robert van Engelen, Johnnie Birch, and Kyle Gallivan, “Array Dependence Testing with the Chains of Recurrences Algebra”, in the proceedings of the IEEE International Workshop on Innovative Architectures for Future Generation High-Performance Processors and Systems (IWIA), January 2004, pages 70-81.
Robert van Engelen and Kyle Gallivan, “An Efficient Algorithm for Pointer-to-Array Access Conversion for Compiling and Optimizing DSP Applications”, in proceedings of the 2001 International Workshop on Innovative Architectures for Future Generation High-Performance Processors and Systems (IWIA), January 2001, pages 80-89.
Robert van Engelen, “Efficient Symbolic Analysis for Optimizing Compilers”, in proceedings of the International Conference on Compiler Construction, ETAPS 2001, LNCS 2027, pages 118-132.
Intel 9/12/05 44
References[Aho86] AHO, A., SETHI, R., AND ULLMAN, J. Compilers: Principles,Techniques and Tools. Addison-Wesley Publishing Company, Reading MA, 1985.[Allen69] ALLEN, F.E. Program optimization, Annual Review in Automatic Programming, 5, pp. 239-307.[Bannerjee88] BANERJEE, U. Dependence Analysis for Supercomputing. Kluwer, Boston, 1988.[Blume94] BLUME, W., AND EIGENMANN, R. The range test: a dependence test for symbolic non-linear expressions. In proceedings of Supercomputing
(1994), pp. 528–537. 22, 2 (1994), 183–205.[Cytron91] CYTRON, R., FERRANTE, J., ROSEN B.K, WEGMAN, M.N, ZADECK, F.K. Efficiently Computing Static Single Assignment Form and the Control
Dependence Graph, ACM Transactions on Programming Languages and Systems, 1991[Franke01] FRANKE, B., AND O’BOYLE, M. Compiler transformation of pointers to explicit array accesses in DSP applications. In proceedings of the ETAPS
Conference on Compiler Construction 2001, LNCS 2027 (2001), pp. 69–85.[Gerlek95] GERLEK, M., STOLZ, E., AND WOLFE, M. Beyond induction variables: Detecting and classifying sequences using a demand-driven SSA form.
ACM Transactions on Programming Languages and Systems (TOPLAS) 17, 1 (Jan. 1995), pp. 85–122.[Goff91] GOFF, G., KENNEDY, K., AND TSENG, C.-W. Practical dependence testing. In proceedings of the ACM SIGPLAN’91 Conference on Programming
Language Design and Implementation (PLDI) (1991), vol. 26, pp. 15–29.[Haghighat95] HAGHIGHAT, M. R. Symbolic Analysis for Parallelizing Compilers. Kluwer Academic Publishers, 1995.[Kennedy81] KENNEDY, K. A survey of data flow analysis techniques, in Muchnick and Jones, (1981), pp.5-54.[Lowry69] LOWRY. E.S. AND MEDLOCK C.W. Object code optimization, Communications of the ACM, 12,( 1991), pp.159-166.[Maydan91] MAYDAN, D. E., HENNESSY, J. L., AND LAM, M. S. Efficient and exact data dependence analysis. In proceedings of the ACM SIGPLAN Conference on
Programming Language Design and Implementation (PLDI) (1991), ACM Press, pp. 1–14.[Muchnick97] MUCHNICK, S. Advanced Compiler Design and Implementation. Morgan Kaufmann, San Fransisco, CA, 1997.[Psarris03] PSARRIS, K. Program analysis techniques for transforming programs for parallel systems. Parallel Computing 28, 3 (2003), 455–469.[Pugh91] PUGH, W., AND WONNACOTT, D. Eliminating false data dependences using the Omega test. In proceedings of the ACM SIGPLAN Conference
on Programming Language Design and Implementation (PLDI) (1992), pp. 140–151.[vanEngelen01a] VAN ENGELEN, R. Efficient symbolic analysis for optimizing compilers. In proceedings of the ETAPS Conference on Compiler Construction,
LNCS 2027 (2001), pp. 118–132.[vanEngelen01b] VAN ENGELEN, R., AND GALLIVAN, K. An efficient algorithm for pointer-to-array access conversion for compiling and optimizing
DSP applications. In proceedings of the International Workshop on Innovative Architectures for Future Generation High-Performance Processor and Systems (IWIA) (2001), pp. 80–89.
[vanEngelen04] VAN ENGELEN, R. A., BIRCH, J., SHOU, Y., WALSH, B., AND GALLIVAN, K. A. A unified framework for nonlinear dependence testing andsymbolic analysis. In proceedings of the ACM International Conference on Supercomputing (ICS) (2004), pp. 106–115.
[Wolfe92] WOLFE, M. Beyond induction variables. In ACM SIGPLAN’92 Conf. on Programming Language Design and Implementation (1992), pp. 162–174.[Wolfe96] WOLFE, M. High Performance Compilers for Parallel Computers. Addison-Wesley, Redwood City, CA, 1996.[Zima90] ZIMA, H., AND CHAPMAN, B. Supercompilers for Parallel and Vector Computers. ACM Press, New York, 1990.[Zima92] ZIMA, E. Recurrent relations and speed-up of computations using computer algebra systems. In proceedings of DISCO’92 (1992), LNCS 721, pp.152–161.