On Fast Array Data Dependence Tests - Semantic Scholar

On Fast Array Data Dependence Tests William Pugh Tatiana Shpeisman University of Maryland, College Park January 3, 1999

Abstract Array data-dependence analysis is an important part of any optimizing compiler for scienti c programs. The Omega test is an exact test for integer solutions to ane constraints and can be used for array data dependence. There are other tests that are less exact but are intended to be faster. Many of these less exact tests are rather complicated and designed to be as accurate as possible while still being fast. In this paper, we describe the Epsilon test, intended to be as simple and as fast as possible, while not being embarrassingly inaccurate. We explore the relative speed and accuracy of the Epsilon and Omega test, and discuss how they might be joined. We also point out serious errors in recent published work on array data dependence tests.

1 Introduction Array data dependence analysis is an important part of any optimizing compiler for scienti c programs. Consider the following code fragment: for i = 1 to n do 1: a[i] := ... 2: ... := a[i-1]

At each iteration the read reaches the same memory location as the write at some previous iteration. In this example the loop iterations are independent if the read of array a at the second statement doesn't fetch the value that was written by the write at the rst statement at the previous iteration. In other words the loop iterations are independent if there is no loop-carried ow dependence from the write to a to the read of a. Simple check of the subscripts shows that at each iteration the read reaches the same memory location as the write of the previous iteration. So this loop cannot be executed in parallel. Assuming all information about loop bounds and array subscripts can be represented as ane functions of symbolic constants and outer loop variables, verifying the existence of a dependence is, in general, an NP-complete problem. Traditionally, compilers have used approximate array data dependence tests that are guaranteed to be fast. To prevent illegal program transformations, any approximate dependence test must be conservative: if the dependence cannot be disproved its existence should be assumed. Traditionally data dependence analysis is performed using several dierent tests that are fast and exact in many special cases that frequently occur in the real programs. The simplest tests are the greatest common divisor (GCD) test, Banerjee's inequalities test [Ban88], zero index variable (ZIV) and single index variable (SIV) tests [GKT91]. The Omega test is an exact test for integer solutions to ane constraints and can be used for array data dependence. It allows us to get an exact answer in many cases where traditional methods do conservative approximations. To compare performance and accuracy of the Omega test with that of a very simple and fast conservative data dependence test we have create a simpli ed version of the Delta test [GKT91] that we call the Epsilon test. 1

Several authors have proposed inexact array data dependence tests that are intended to be accurate but reasonably fast. A goal of this paper is to examine the characteristics of very simple and fast array data dependence tests and to raise questions about the value of dependence tests that explore the middle ground between fast and exact. The remainder of this paper is organized as follows; Section 2 presents the standard de nitions and notation used in data dependence analysis. In Section 3 we describe dierent data dependence tests whose accuracy and performance we study. In Section 4 we give the experimental results and compare accuracy and performance of the dierent dependence tests. In Section 5 (and Appendix A) we discuss some problems and errors in related work.

2 De nitions and notation We say that there is a data dependence between two accesses to a variable if those accesses touch the same memory location. Depending on the kind of the accesses data dependencies can be of four following types:  ow (true) data dependence occurs when rst access is write and second access is read.  anti data dependence occurs when rst access is read and second access is write  output data dependence occurs when both accesses are writes  input data dependence occurs when both accesses are reads Unlike ow, anti or output dependencies, the input dependencies do not impose ordering constraints on the loop iterations and are often ignored by the dependence analyzers. Consider the following loop nest: for i1 = L1 to U1 by N1 do ::: for ic = Lc to Uc by Nc do for ic+1 = Lc+1 to Uc+1 by Nc+1 do ::: for im1 = Lm1 to Um1 by Nm1 do A[f1(i1 ; i2;... ; im1 );.. . ; fs (i1 ; i2;.. . ; im1 )] endfor ::: endfor for ic+1 = Lc+1 to Uc+1 by Nc+1 do ::: for im2 = Lm2 to Um2 by Nm2 do A[g1(i1 ; i2;.. . ; in );... ; gs(i1 ; i2;... ; im2 )] endfor ::: endfor endfor ::: endfor Let I and I0 be vectors of the loop indices i1 : : :in , F and G be vectors of the subscript functions f1 : : :fs and g1 : : :gs. Let L, U and N be vectors of the lower loop bounds, upper loop bounds and strides correspondently. There is a data dependence between two accesses to A if and only if F(I) = G(I0) and L  I; I0  U and9; 2 Z s:t: I = L +   N and I0 = L +  N and I lexicographically precedes I0 . Traditionally data dependence is abstracted by data dependence distance and/or data dependence vector. In our notation data dependence distance is vector D = I0 ? I. Dependence direction vector d = (d1; : : :; dn) is a sign vector in which every element di can be +, 0 ,? or their combination depending on the possible signs of the corresponding dependence distance. 2

In the future we shall refer to the variables i1 : : :in as loop indices or just indices and to the functions f1 : : :fs ; g1 : : :gs as subscript expressions or just subscripts. In general subscript can be any function of the loop indices. We will be mainly concern with the special but frequently occurring in practice case when subscript is an ane function of the loop indices: fi = Ai;1i1 +: : :+Ai;nin +Ai;0 gi = Bi;1 i1 +: : :+Bi;n in +Bi;0 Depending on the number on the non-zero coecients in the above formula the subscripts can be divided into three categories:  ZIV (zero index variable) - subscript contains no index variables  SIV (single index variable) - subscript contains one index variable  MIV (multiple index variable) - subscript contains two or more index variables Special data dependence tests that can be applied to each subscript category are described in the next section.

3 Data dependence tests Data dependence testing has been a subject of extensive studies during the recent years. Here we describe several data dependence tests that we use as the building blocks for the Epsilon test or compare with the Epsilon test.

3.1 Tests used by the Epsilon test

This test can be applied to the couple of ZIV subscripts. If the system determines that two loop invariant expressions cannot be equal the data dependence is disproved. Otherwise the subscript does not contribute any dependence information and can be ignored. ZIV test.

This test can be applied to the couple of SIV subscripts that contain the same index variable. The two simplest cases of this test are strong SIV test and weak-zero SIV test.

SIV test.

This test can be applied to the subscripts in the form (ai + c1 ; ai0 + c2 ). The dependence distance is d = c1 ?a c2 . If a does not divide c1 ? c2 the existence of the dependence is disproved. Also there is no dependence unless jdj  jU ? Lj. If the lower loop bound L is constant and the loop stride N greater than 1, the there is no dependence unless N divides d. Strong SIV test.

Weak-zero SIV test. This test can be applied to the subscripts in the form (a1 i + c1 ; a2 i0 + c2 ) where one of the index coecients a1 or a2 is zero. If, for example, a2 is zero the dependence equation is reduced to i = c2 ?a c1 . The dependence exists if i is an integer, within the loop bounds and satis es the loop stride constraint. In general weak-zero SIV test cannot determine the direction distance or vector, except in the special case when i is equal to the lower or upper loop bound.

3.2 Banerjee's test

The Banerjee's test is a popular data dependence test that can be applied to a couple of ane subscripts within the loops with the constant lower and upper bounds and stride. The general idea behind the Banerjee's test is to calculate ranges of the subscript functions. If two ranges do not intersect no data dependence can exist. Michael Wolfe gives a modi ed version of the test to test for the data dependence with the particular dependence vector [Wol89]. For each term in the subscript expression its lower and upper bounds LB d and UB d for a given direction d are calculated. The ranges of two subscript expressions intersect if

Xn LBkd  B0 ? A0  Xn UBkd k=1

k=1

3

, where d is one of the possible directions: +,0,? or *. There also exists a specialized version of the Banerjee's test that allows to handle triangular loop bounds. The Banerjee's test is a necessary condition test, i.e., if it fails, the dependence is disproved, but if it passes additional tests are necessary to prove that dependence really exists.

3.3 Epsilon test

Epsilon test is a simpli ed version of the Delta test [GKT91] that has been designed specially for the purpose of comparing Omega test with the traditional data dependence methods. Our goal was to create a very simple and ecient test that would not be embarassingly inaccurate. To do so we restricted ourselves to the special treatment of only most frequently occuring cases. As a result Epsilon test has several limitations compared to the Delta test: only the most simple cases of the SIV subscripts are considered, we do not handle symbolic constants in the subscripts, we do not use restricted double index variable (RDIV) and greatest common divisor (GCD) tests and we do not handle triangular loop bounds in the Banerjee's test. The Epsilon test algorithm is shown at Figure 1. Epsilon test employs the ZIV, SIV and Banerjee's tests. First, it tries to disprove the dependence or discard some subscripts by applying the ZIV test. At the same time the subscripts are investigated. None of the above tests can handle non-ane subscripts or subscripts with the symbolic constants so such subscripts are simply discarded. As a result the Epsilon test can give a conservative answer for the accesses that contain such subscripts. If ZIV test is not sucient to prove or disprove dependence the SIV tests are applied. The constraints resulting from applying SIV test to a single subscript are propagated to the other subscripts. This allows us to prove or disprove a dependence using just SIV tests for many cases where SIV tests are not applicable directly. If the dependence is still neither proved nor disproved the Banerjee's test is used. The Banerjee's test itself is not sucient to prove the dependence. If the subscripts are ane functions of the loop indices and the loop bounds and strides are constants the combination of the Banerjee's and GCD test can be applied to get an exact answer. Yet, we do not employ GCD test here because we believe that vast majority of the cases for which it could disprove otherwise assumed dependence are handled by the combination of SIV tests. If the loop bounds are non-constant but are function of symbolic constants and/or other loop indices we assume that they are unknown. This assumption can also contribute to the inexactness of the Epsilon test. While applying Banerjee's inequalities we use a set of engineering tricks described in [Wol93]: we do not expand direction vector hierarchy for the index in the direction that have been disproved by one of the previous tests, we do not expand direction vector hierarchy for the index variable if this variable does not occur in this subscript, we use direction vectors information that we obtained from the SIV tests, we do not re ne hierarchy for the loop index that does not occur in any subscripts. To speed up the data dependence testing the Epsilon test tests a dependence between two accesses without taking in the account precedence information. If the dependence is not disproved the dependence and corresponding direction vectors are split on ow and anti dependencies or couple of the output dependencies. The Epsilon test algorithm can exit at dierent stages of its work. We can divide all array access pairs on four categories based on this criteria:  ZIV tests are sucient to prove or disprove dependence (algorithm exits at lines 14 or 39 and the answer is not marked as conservative)  SIV tests with constraint propagation (\simple" tests) are sucient to prove or disprove dependence (algorithm exits at lines 26, 31 or 39 and the answer is not marked as conservative)  Banerjee's tests have to be used for the dependence testing (algorithm exits at line 45).  the dependence is assumed because it can be neither proved nor disproved (algorithm exits at line 39 and the answer is marked as conservative)

4

1: 2: 3: 4: 5: 6: 7: 8: 9: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45:

for

each loop l do l does not have constant bounds and stride mark answer as conservative

if

endif endfor for

each subscript s do s is non-ane or s contains symbolic constants discard s and mark answer as conservative

if

endif if

s is a ZIV subscript

apply ZIV test if dependence is disproved return

endif

discard s

endif endfor

propagate constraints := True propagate constraints do propagate constraints := False for each subscript s do if s is SIV subscript apply strong or weak-zero SIV test if dependence is disproved

while

return

endif

propagate constraints := True propagate SIV test constraints to all other subscripts if dependence is disproved return

endif break endif endfor endwhile if

there are no subscripts left record answer return

endif

apply Banerjee's tests to the rest of the subscripts if dependence is not disproved mark answer as conservative endif

return

Figure 1: The Epsilon test algorithm

5

3.4 Omega test

The Omega test uses integer programming techniques to solve data dependence problem. Description of the Omega test and its application to data dependence analysis can be found in [Pug92, PW92, PW93]. The Omega test gives the exact result unless there are non-ane subscripts or loop bounds or symbolic strides.

3.5 Epsilon-Omega test

Epsilon-Omega test is a simple combination of the Epsilon and Omega tests. First, we run the ZIV tests at the same time checking for the conditions that make the Epsilon test to mark its answer as a conservative (the subscript expressions are not ane functions of the loop indices or the loop bounds and strides are not constants.) If the dependence is neither proved nor disproved and the above conditions do not hold we proceed with the SIV tests. Finally, if the answer is still unknown the Omega test is called to solve the data dependence problem. The standard Epsilon test would proceed at this stage to use Banerjee's test. The Epsilon-Omega test instead employs the Omega test that starts analyzing dependence from scratch. Theoretically the Epsilon-Omega test could be slower than the Omega test because of the additional work performed by the Epsilon test. Yet, our experimental results (see Section 4) show that it never really happens in practice.

4 Experimental results We have compared the accuracy and performance of the Epsilon, Banerjee's, Omega and Epsilon-Omega tests. The tests have been implemented within the framework of our research tool Petit [KMP+ 96]. Before applying any of the tests we have performed very aggressive induction variable recognition and forward substitution (see Section 5.1). Also, we performed dependence analysis only for the array access pairs sharing at least one common loop. The experiments have been run on SPARC Station 10. Our test suite consisted of ten procedures extracted from the NASA and Perfect Club benchmarks or suggested by other researchers as good test programs.

4.1 Comparing the tests accuracy

All the data dependence tests are conservative, that is, they assume the data dependence when they cannot disprove it. The Omega test is guaranteed to give the correct answer if the array subscripts and loop bounds are ane expressions and the loop strides are constants. The Epsilon test is much simpler and might give a conservative result due to many factors such as:  Non-ane subscripts or loop bounds  Symbolic loop strides  Symbolic loop bounds  Non-index variables in the subscripts  Triangular loop bounds  Conditional operators and assertions that impose additional constraints The Banerjee's test and Epsilon-Omega tests have exactly the same accuracy as Epsilon and Omega tests, correspondently. Thus, it is sucent to compare the accuracy of Epsilon and Omega tests. In the absence of non-ane subscripts or loop bounds and symbolic loop strides Omega test always gives the correct result. If under these conditions the Epsilon test reports a dependence while the Omega test disproves it the Epsilon test answer is a conservative one. Note, that a reverse situation when the Epsilon test disproves the dependence that is not disproved by the Omega test is impossible. Under conditions when the Omega test might be conservative we cannot say anything about the accuracy of the results unless we investigate an access pair manually. 6

Program Access pairs number cholsky s99 interf poteng nl lt btrix yacobi dctdx radb4 vpenta

82 176 1456 777 127 518 376 63 56 261

Percentage of the access pairs for which Epsilon is correct Epsilon is conservative 89 11 100 0 94 6 100 0 100 0 100 0 8 92 100 0 100 0 100 0

Table 1: Accuracy of the Epsilon and Omega tests

Program cholsky s99 interf poteng nl lt btrix yacobi dctdx radb4 vpenta

Program features non-ane Symbolic Symbolic Triangular None of subscript subscript loop loop the listed bound bound 0 30 100 52 0 0 0 100 0 0 0 0 9 3 90 0 0 1 0 99 16 0 31 0 51 0 25 70 0 29 0 0 100 93 0 0 39 60 0 4 0 17 100 0 0 0 0 0 0 100

Table 2: Percentage of the access pairs exhibiting various program features among the pairs for which the Epsilon test is correct

Program cholsky interf yacobi

Program features non-ane Symbolic Symbolic Triangular None of subscript subscript loop loop the listed bound bound 0 100 100 0 0 0 0 100 100 0 0 0 100 100 0

Table 3: Percentage of the access pairs exhibiting various program features among the pairs for which the Epsilon test is conservative

7

Program cholsky s99 interf poteng nl lt btrix yacobi dctdx radb4 vpenta

Number of Percentage of access pairs for which the Epsilon test access pairs Stopped Stopped Stopped after Assumed tested after ZIV after SIV Banerjee's tests dependence 82 0 43 56 0 176 0 15 84 0 1456 28 57 14 0 777 40 57 2 0 127 36 40 6 16 518 44 24 31 0 376 0 8 91 0 63 4 39 15 39 56 64 35 0 0 261 71 28 0 0

Table 4: Distribution access pairs between dierent subtests categories We have compared the results of the Epsilon and Omega tests for every pair of the tested array accesses for several programs. Table 1 shows the summary of our results. For 7 procedures out of 10 that we investigated the Epsilon test always gives the correct result. We also measured the percent of the array access pairs exhibiting features that may cause the Epsilon test to be inaccurate such as non-ane subscript functions, symbolic subscript functions, symbolic subscript bounds and triangular loop bounds. None of the programs we tested has non-ane loop bounds or symbolic loop strides. We considered the array access pairs for which the Epsilon test gives the correct answer separately from those for which the Epsilon test gives the conservative answer. The results are shown in Tables 2 and 3. In Table 3 we do not show the all zero lines that correspond to the programs on which the Epsilon test is always correct. As can be seen from the Table 2 the Epsilon test often gives the exact result even in the presence of the program features that may cause it to be conservative. For example, for procedure ffs99 the Epsilon test is always correct although all the loops in this procedure have at least one symbolic bound. All of the access pairs for which the Epsilon test is conservative have either symbolic constant in the subscript or triangular loop bounds. We have manually investigated the procedure nlfilt to check the accuracy of the results produced by the Epsilon and Omega tests for the accesses with non-ane subscripts. Our investigation showed that both of the tests give the correct result. Although it is possible that for the particular input data some of the dependencies do not exist it cannot be proven unless additional information is provided by the user.

4.2 Categorizing access pairs by the complexity of tests used to prove or disprove dependence

As described in the Section 3 the array access pairs can be categorized depending on what subtests were employed by the Epsilon test to test the dependence. Table 4 shows the distribution of the access pairs between these categories. For many access pairs simple ZIV test is enough to prove or disprove data dependence. Most part of the rest of the access pairs can be handled by combination of the SIV tests. For many programs less then 15% of the access pairs are analyzed using comparatively expensive Banerjee's tests. For 16 % of the access pairs for procedure nlfilt the dependence has been assumed due to the presence of the non-ane subscript expressions. These kind of accesses cannot be analyzed exactly by the Omega test either. For procedure dctdx the dependence has been assumed for 39% of the array access pairs tested. This happened because the Epsilon test cannot analyze the subscript expressions with symbolic constants. Still, the assumed dependencies really exist, as they are also reported by the Omega test, that gives an exact answer. Thus, here the Epsilon test gives the correct answer even if it marks it as being a conservative one. We measured the time that the Epsilon and Omega tests spend analyzing individual access pairs belonging to the dierent groups. The results for procedure btrix are shown in Figure 4.2. Dierent markers correspond to the dierent groups of the access pairs. Both the Omega and Epsilon tests are rather fast 8

0.4 "stops_after_ZIV_test" "stops_after_SIV_test" "stops_after_Banerjee_tests"

Epsilon test time, milliseconds

0.35 0.3 0.25 0.2 0.15 0.1 0.05 0 0

0.5

1 1.5 2 Omega test time, milliseconds

2.5

Figure 2: Individual access pairs time analyzing the ZIV subscripts. Sometime the Omega test is signi cantly slower than the Epsilon test when the SIV test is sucient. This happens because the Omega test always spends some time building a problem. In case of the SIV subscripts this time becomes comparable with the problem analyzing time. Another reason for the Omega test to be much slower than the Epsilon test in these cases is that often the Epsilon test can discard the subscripts that it cannot handle. As a result the simple SIV tests are sucient to analyze the rest of the subscripts. The problem that is being solved by the Omega test can be much more complicated in such a case. The time the Epsilon test spends on the analyzing an array access pair using Banerjee's tests can vary depending on the kind of the problem. In the worst case it is necessary to expand the full hierarchy of the dependence vectors that can be rather time consuming.

4.3 Comparing the performance results

We compare the performance results of the following tests: Epsilon test, Omega tests, Banerjee's tests and Epsilon-Omega test. Table 5 shows the average access pair analysis time for the dierent tests The Epsilon test is very fast for the programs that have a lot of the access pairs that can be analyzed by simple tests. For the programs with more complicated array accesses, such as yacobi the Epsilon test is only 2 times faster than the Omega test and gives inexact result for 92 % of the access pairs. The Banerjee's test is only slightly slower than the Epsilon test. As it was expected, the Epsilon-Omega performance is in between the Epsilon and Omega test performances. It works signi cantly faster than the Omega test for the programs that have a lot of the simple (ZIV and SIV) array access pairs, such as vpenta, poteng, interf. Although for some cases the Epsilon-Omega test can perform simple tests in addition to the Omega test it is never noticeably slower than the Omega test. Although the Omega test takes 2-12 time longer than the Epsilon test, the time spent for the data dependence analysis using the Omega test is small compared to the compilation time. Table 6 shows the Omega test data dependence analysis time and the compilation time required to compile a program using 9

3

Program cholsky s99 interf poteng nl lt btrix yacobi dctdx radb4 vpenta

Avg. access pair analysis time in milliseconds Epsilon Omega Banerjee's Epsilon-Omega 0.08 0.65 0.13 0.63 0.13 0.60 0.13 0.60 0.06 0.54 0.08 0.16 0.04 0.32 0.06 0.06 0.03 0.35 0.05 0.15 0.05 0.34 0.07 0.21 0.29 0.74 0.31 0.74 0.04 0.28 0.05 0.20 0.02 0.23 0.04 0.14 0.02 0.12 0.03 0.02

Table 5: Performance results

Program cholsky s99 interf poteng nl lt btrix yacobi dctdx radb4 vpenta

Compilation Omega test Epsilon-Omega test time analysis time analysis time seconds seconds % seconds % 2.2 0.05 2.2 0.05 2.2 3.4 0.11 3.2 0.11 3.2 3.1 0.79 25.5 0.23 7.6 4.5 0.25 5.6 0.05 1.0 2.0 0.04 2.0 0.02 0.9 5.1 0.17 3.3 0.11 2.1 1.2 0.28 23.3 0.28 23.3 0.6 0.01 1.7 0.01 1.2 2.6 0.01 0.3 0.01 0.2 2.1 0.03 1.4 0.01 0.2

Table 6: Data dependence analysis and compilation times.

10

Number of Induction variable dependent Dependence recognition and forward array pairs test substitution done? 5528 Epsilon no 5528 Omega no 5224 Epsilon yes 998 Omega yes Table 7: Dependent array pairs in FFS99 (including array pairs not surrounded by common loop) f77 compiler with -c -O3 options on

SPARC Station 10. For most of the programs the data dependence analysis time does not exceed 5 % of the compilation time. Among our test codes we have two exceptions: interf and yacobi, whose data dependence analysis takes about 25 percentage of the compilation time

5 Problems in related work A number of recently published papers [CC98a, CC98c, CC98b] on array data dependence tests contained serious errors and dubious methodology. Some of these errors are dangerous errors that they would lead one to believe that no data dependence existed in a situation where a dependence did, in fact, exist. Errors in the Generalized Lambda Test paper, the In nity Lambda Test paper and the I+ Test paper are described in the appendix.

5.1 Induction variable recognition and forward substitution

A number of previous papers on array data dependence tests have not stated whether they performed induction variable recognition and scalar forward substitution. In some cases [CC98a, CC98c, CC98b], we have veri ed by personal communication that they were in fact not done. Not doing these transformations makes it impossible to study array data dependence tests. Table 7 shows the eect of induction variable recognition and forward substitution on dependence test accuracy for the FFS99 subroutine. Unlike the results reported in earlier tables, here we tested dependences between array pairs not surrounded by a common loop. As you can see, without these induction variable recognition and forward substitution, the Epsilon test appears to be exactly as accurate as the Omega test even on top-level dependences. With these transformations, there is a substantial dierence in their accuracy.

6 Conclusions We compared the accuracy and performance of the Omega, Epsilon, Banerjee's and Epsilon-Omega tests on set of programs from the NASA and Perfect Club benchmarks. For all the programs we tested the Epsilon test is the fastest. The Epsilon test is especially ecient for the programs that contain a lot of access pairs that can be analyzed by the ZIV or SIV tests. It works about 2 times faster than the Banerjee's tests and about 10 times faster than the Omega test. For such programs the Epsilon test almost always gives the correct answer. Still there are programs for which almost all the answers given by the Epsilon test are conservative. Although the Omega test is slower than the inexact methods, it does not produce a signi cant overall performance degradation. We were pleasantly surprised that despite the simplicity of the Epsilon test, it is quite accurate. We believe this calls into question the idea of using complicated inexact data dependence tests. A number of recently papers on complicated inexact data dependence tests have been shown to have serious errors, and this is another reason to be weary of complicated data dependence tests unless they provide a signi cant advantage. 11

Combining the Omega test with the Epsilon test is a useful idea that results in substantial speed improvements in some cases, and we have not seen a speed degradation. We have folded this into the petit program analysis tool [KMP+ 96] as the default data dependence test.

References [Ban88] [CC98a]

U. Banerjee. Dependence Analysis for Supercomputing. Kluwer Academic Publishers, 1988. Weng-Long Chang and Chih-Ping Chu. The generalized lambda test. In Proceedings of the 1998 International Parallel Processing Symposium, pages 181{186, March 1998. [CC98b] Weng-Long Chang and Chih-Ping Chu. The i+ test. In Proceedings of the 11th International Workshop on Languages and Compilers for Parallel Computing, pages 181{186, August 1998. [CC98c] Weng-Long Chang and Chih-Ping Chu. The in nity lambda test. In Proceedings of the 1998 International Conference on Supercomputing, pages 181{186, July 1998. [GKT91] G. Go, Ken Kennedy, and Chau-Wen Tseng. Practical dependence testing. In ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, 1991. [KKP90] X. Kong, D. Klappholz, and K. Psarris. The I test: A new test for subscript data dependence. In Proceedings of the 1990 International Conference on Parallel Processing, August 1990. [KMP+ 96] Wayne Kelly, Vadim Maslov, William Pugh, Evan Rosser, Tatiana Shpeisman, and David Wonnacott. Petit: a tool for analyzing and transforming array calculations. Dept. of Computer Science, University of Maryland, College Park, April 1996. see http://www.cs.umd.edu/projects/omega/index.html. [Pug92] William Pugh. The Omega test: a fast and practical integer programming algorithm for dependence analysis. Communications of the ACM, 35(8):102{114, August 1992. [PW92] William Pugh and David Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-3191, Dept. of Computer Science, University of Maryland, College Park, December 1992. An earlier version of this paper appeared at the SIGPLAN PLDI'92 conference. [PW93] William Pugh and David Wonnacott. An exact method for analysis of value-based array data dependences. In Proceedings of the 6th Annual Workshop on Programming Languages and Compilers for Parallel Computing, volume 768 of Lecture Notes in Computer Science. Springer-Verlag, Berlin, August 1993. [Wol89] Michael Wolfe. Optimizing Supercompilers for Supercomputers. Pitman Publishing, London, 1989. [Wol93] Michael Wolfe. Engineering a data dependence test. Concurrency: practice and experience, 5(7), October 1993.

12

A Errors in Related Work

A.1 The Generalized Lambda Test

There are a number of problems with the Generalized Lambda Test paper [CC98a]. Through personal communication with the authors, we found that their implementation assumes that any unknown lower loop bound is 0 and any unknown upper loop bound is 100. There are also a number of mathematical errors in the derivation of their algorithm. For example, de nition 3-1 is erroneous. Let x2k?1 and x2k be two loop variables that are constrained by the direction vector k = `