W. Pugh and D. Wonnacott. Going beyond integer programming with the omega test to eliminate false data dependences. IEEE Transactions on Parallel and Distributed Systems, 6(2):204--211, Feb. 1995. 4.1.3  Home/Search   Document Details and Download   Summary   Related Articles   Check

....achieves the same or greater speedup than parallelization would while using fewer processors. In the latter case, resource requirements and communication costs are substantially reduced. Additionally, for this powerful optimization, we make use of techniques and tools for array dependence analysis [23, 24, 54, 55, 64, 65, 66] and source to source transformation [6, 41, 55, 63, 69] that were developed for parallelizing compilers. Comparing the straightforward code (1) with the optimized code (27) in Section 6, one can see that performing the optimizations by hand is tedious and error prone. A central goal of ....

....solving integer linear constraints, we rst transform each of the contributing sets into a form that constrains the array subscripts explicitly based on the subscript expressions and the ranges of loop variables. Then we use the methods and tools developed by Pugh et al. in the Omega project [64, 65, 66] to simplify the constraints. This method is embodied in the following algorithm. It rst transforms both given sets by introducing fresh variables to capture subscripts of the array references and adding existential quanti ers to the loop variables. It then simpli es the constraints given by ....

[Article contains additional citation context not shown here]

W. Pugh and D. Wonnacott. Going beyond integer programming with the omega test to eliminate false data dependences. Technical Report CS-TR-3191, Department of Computer Science, University of Maryland, College Park, Maryland, Dec. 1992. An earlier version of this paper appeared at the ACM SIGPLAN '92 Conference on PLDI.

....x in 1 never can reach 5. In the MOP framework, all possible paths are considered. For instance, the two paths denoted with dashed lines in Figure 2 (i.e. paths 1:4 and 2:3) These paths, however, never correspond to an actual execution. Our analysis takes advantage of a symbolic solver, Omega [14], to avoid this loss of precision. In particular, Omega provides uninterpreted functions that allow to manipulate functions on which we have little or no knowledge. On an uninterpreted function F , Omega is able to perform logic operations such as simplifying F (x) 0 F (x) 0 to true, or ....

W. Pugh and D. Wonnacott. Going beyond integer programming with the omega test to eliminate false data dependences. Technical Report CS-TR-3191, U. of Maryland, December 1992.

....a (usually perfect) loop nest that enforces this new execution order. This can be carried out using one of several existing methods, including the Fourier Motzkin elimination [3] Feautrier s parametric integer programming (PIP) 12] the Omega Calculator developed by Pugh and his associates [21, 22], and the algorithm described in [27] An extension to allow non unimodular transformations exists [29] Unfortunately, this unimodular approach is limited to perfect loop nests only. In the case of imperfect loop nests, several techniques have been suggested, including loop distribution [28] and ....

....for verifying the legality condition of the NBBL transformation for an n deep loop nest. In its full generality, the legality test is a form of integer programming. We note that the legality of NBBL can be tested, in general, using the Omega Calculator developed by Pugh and his associates [21, 22]. The Omega Calculator contains a set of routines for manipulating Presburger formulas. Presburger formulas are the expressions consisting of affine constraints over integer variables and the usual logical connectives and quantifiers. Let C be a conjunction of affine constraints obtained from the ....

W. Pugh and D. Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-3191, Department of Computer Science, University of Maryland, Dec. 1992. Earlier version at SIGPLAN PLDI's 92 conference.

....can direct thread dispatch using a fork primitive, and obviate the need for hardware prediction and eliminating any potential misprediction overhead. Similarly, there are many scenarios where an advanced parallelizing compiler can either detect and guarantee no data dependences among threads exist [7,27,14] or can eliminate the data dependences (e.g. through array privatization [34,16] In such scenarios, the hardware unnecessarily tracks data dependences, limiting the scope of parallelism to the buffering capacity in the L1 caches. 3 Multiplex: Unifying Explicit Implicit TLP on a CMP In this ....

....eliminate hardware speculation overhead, and realize the raw hardware speeds of multiple CMP cores. Multiplex relies on a state of the art parallelizing compiler to analyze programs and generate explicit threads. These compilers (e.g. Polaris [6] SUIF [17] use a myriad of techniques to test [7,27,14] and eliminate data dependence in program segments [3,34,26,16] Moreover, these compilers increase thread performance in analyzable program segments through code transformations to optimize for memory hierarchy locality and communication latency [17] In explicit threading, thread size plays a ....

W. Pugh. Going beyond integer programming with the omega test. IEEE Transactions on Parallel and Distributed Systems, 6(2):204--211, Feb. 1995.

....flow analysis [8] Memory based dependences can then be calculated by taking the transitive closure of the set of value based dependences. In contrast, determination of value based dependences for array variables requires more sophisticated and computationally expensive analysis techniques [9] [10]. While many program optimizations, such as code scheduling, require only memorybased dependences for validity checking, some require value based dependences. Determination of value based dependences are necessary for optimizations such as scalar replacement [7] which require knowledge of the ....

....array of complex values, such as cb.c. 1] r, are grouped in the access 31 COMMON CB C, D, R, M COMPLEX C(10) DOUBLE PRECISION D(10) REAL R(10) LOGICAL M(10) IF (M(1) C(1) C(2) C(3) CALL FOO(C(1) R(2) D(1) STOP (a) typedef struct f float r, i; g complex; struct f complex c[10]; double d[10] float r[10] int m[10] g cb; main( f complex q; if (cb.m[0] f q.r = cb.c[1] r cb.c[2] r, q.i = cb.c[1] i cb.c[2] i; cb.c[0] r = q.r, cb.c[0] i = q.i; g foo(cb.c, cb.r[1] cb.d) g (b) Figure 4.2: F2c Translation of Common Blocks and Complex Variables. table ....

[Article contains additional citation context not shown here]

W. Pugh and D. Wonnacott, "Going beyond integer programming with the Omega Test to eliminate false data dependences," Tech. Rep. CS-TR-2993, Department of Computer Science, University of Maryland, College Park, December 1992. 95

....the transformation (not necessarely unimodular) they apply afterwards is the same for all of them. In [DRR93] a parallel scheduling technique for loop nests is proposed which extends the hyperplane method [Lam74] by using a different affine scheduling for each statement in the nest. Pugh et al. [KPR94, PW92] has proposed a different approach to multi transformations. Their approach is based on the Omega package, which contains a collection of procedures for manipulating formulas in the first order theory of Presburger arithmetic. Mappings and the validity problem for them can be formulated in this ....

W. Pugh and D. Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-2993, Dept. of Computer Science, Univ. of Maryland, 1992.

....all dependences. The process of elimination will also help reduce the time complexity of later stages. Although more dependences could be removed at this stage it is unnecessary, as it will not reduce the complexity of the Fast First Sink Algorithm. For this reason, we do not use cover analysis [16], as the additional expense it will incur does not reduce the cost, or improve the accuracy, of later stages. In the algorithm described in [6] synchronisation instructions were first inserted before the elimination of redundant dependence was considered. In contrast we apply dependence ....

W. Pugh, D. Wonnacott, Going beyond Integer Programming with the Omega Test to Eliminate False Data Dependences, Tech. Rep. UMIACS-TR-93-132, Univ. of Maryland, Dec 1992

....Also their algorithm does not seem to handle non affine program fragments. Pugh and Wonnacott work. Pugh and Wonnacott use kill analysis to compute exact dependence information, that is, they first compute memory based dependences and then kill or refine them by techniques originally described in [PW92] and [PW93b] Since their kill analysis in the worst case considers all write killer read triples, while we in the worst case consider only all write read pairs, the kill analysis can be expensive. So they have incorporated our idea of keeping track of the read instances that were already ....

....be described as our DNF package minus RelMax functions plus 8 and 9 quantifiers that can appear at any level of the formula) to perform the kill analysis equivalents of these operations. They also use memory based dependences to perform some quick kills as it was suggested in the earlier paper [PW92] while we do not need them at all. However, if need be, we can compute the memorybased dependences with ease. Both approaches are implemented in the Tiny tool, originally developed by Michael Wolfe and then considerably enhanced in the University of Maryland, College Park, so it is possible to ....

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.

....tuples in these sets. The input tuple sets must be convex (as my iteration spaces always are) and the result (by definition of the hull operation) will also be convex. A tuple set is convex if it can be represented as a conjunction of affine equality and inequality constraints. The gist operator [PW92, Won95] is used to simplify a set of constraints given that some other set of constraints is known to be true. The only guaranteed property of the gist operator is: gist(A; B) B , A B However, the techniques used to compute gist are designed to produce simple (often minimal) sets of ....

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.

....for the different iterations together. Note that in some definitions of dependence it is required that there does not exist a statement S 3 which is executed between S 1 and S 2 and which writes to the same variablei [ZC90] Dependences with this extra condition are called value based dependences [PW92]. We do not require this extra condition. The resulting notion of dependence is called memory based depedence [PW92] Finally, given an expression e containing a variable x, the expression e[e 0 =x] denotes the substitution of e 0 for x in e. Likewise, given a collection of variables x 1 ; ....

....exist a statement S 3 which is executed between S 1 and S 2 and which writes to the same variablei [ZC90] Dependences with this extra condition are called value based dependences [PW92] We do not require this extra condition. The resulting notion of dependence is called memory based depedence [PW92]. Finally, given an expression e containing a variable x, the expression e[e 0 =x] denotes the substitution of e 0 for x in e. Likewise, given a collection of variables x 1 ; xn and a collection of expressions e 1 ; e n , the expression e[ e= x] denotes the simultaneous ....

[Article contains additional citation context not shown here]

W. Pugh and D. Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-2993, Dept. of Computer Science, Univ. of Maryland, 1992.

....paper we describe techniques for simplifying polynomial constraints. This work supersedes our previous work on dependence testing of non linear subscripts [Mas92] and allows us to handle polynomial constraints that arise in a number of situations. This work is also an extension of the Omega test [Pug92, PW92, PW93] the system that simplifies conjunctions of affine constraints over integers and performs exact elimination of existentially quantified variables. Polynomial constraints arise in a number of situations: ffl Dependence between references with linearized subscripts, ffl Complicated terms in ....

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.

....variables such as n in the following example: f [i] i 1] j 1 i n g. These free variables correspond to symbolic constants or parameters in the source program. We use Sym to represent the set of all symbolic constants. Tuple relations and sets are represented using the Omega test [Pug92, PW92, PW93] which is a package for manipulating affine constraints over integer variables. We introduce new variables corresponding to each of the input positions and output positions. Relationships between these variables and those corresponding to symbolic constants are represented as a disjunction ....

....positions and output positions. Relationships between these variables and those corresponding to symbolic constants are represented as a disjunction of convex regions. See [Pug91] for a more thorough description. The gist operation We make use of the gist operation, originally developed in [PW92] Intuitively, gist p given q) is defined as the new information contained in p, given that we already know q. More formally, if p q is satisfiable then (gist p given q) is a conjunction containing a minimal subset of the constraints in p such that ( gist p given q) q) p q) otherwise it ....

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.

....and notice is given that copying is by permission of the Association for Computing Machinery, Inc. ACM) To copy otherwise, to republish, to post on servers, or to redistribute to lists requires prior specific permission and or a fee. c fl 1998 ACM 0164 0925 98 0300 0388 5.00 2 Delta W. Pugh and D. Wonnacott for i : 2 to n do sum : 0.0 for l : 1 to i 1 do sum : sum A[l,i] B[l] endfor B[i] B[i] sum endfor (a) forall i : 1 to n do sum[i] 0.0 endfor for l : 1 to n 1 do B[l] B[l] sum[l] forall i : l 1 to n do sum[i] sum[i] A[l,i] B[l] endfor endfor (b) Fig. 1. a) From Petersen and Padua ....

Pugh, W. and Wonnacott, D. 1995a. Going beyond integer programming with the Omega test to eliminate false data dependences. IEEE Trans. Parallel Distributed Systems, 204--211.

....To do so, we introduce variables corresponding to these differences, and existentially quantify and eliminate all other variables. Alternatively, we can choose to eliminate everything but the symbolic constants, and thus determine the conditions under which the dependence exists ( PW92] Program to be analyzed: for j = 0 to 20 do for i = max( j, 10) to 0 do for k = max( j, 10) i to 1 do for l = 0 to 5 do a(l, i,j) a(l, k,i j) Constraints before equality substitution: 9j w ; i w ; kw ; l w ; j r ; i r ; k r ; l r s:t: Deltai = i r Gamma i w Deltaj = j r ....

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.

....current implementation, this simplification requires 5 milliseconds on a Sun SparcStation 10 51. The above equation for value based dependence analysis is best thought of as a denotational specification of what we compute. Using the techniques for valuebase dependence analysis described in [PW92a, PW94] as a prepass, followed by the techniques described here, decreases the total cost of value based dependence analysis by a factor of 0:9 Gamma 1:75 while not changing what is computed. In [PW93] we describe a number of techniques that decrease the cost of value based dependence analysis by a ....

....analysis by a factor of 0:9 Gamma 1:75 while not changing what is computed. In [PW93] we describe a number of techniques that decrease the cost of value based dependence analysis by a factor of 1:1 Gamma 2:9 and eliminate the need to perform a prepass using the techniques described in [PW92a, PW94] 3.5.1 Simplifying formulas containing negation. When performing array kill analysis, we have to simplify formulas of the form: C 0 : 9V 1 s:t: C 1 ) 9Vn s:t: Cn ) Here, the C i s are conjunctions of linear constraints, and the V i s are (possibly empty) sets of ....

William Pugh and David Wonnacott. Going beyond integer programmingwith the Omega test to eliminate false data dependences. IEEE Transactions on Parallel and Distributed Systems, 1994. To appear.

....In Section 4 we describe an algorithm that tests whether a mapping is legal. In Section 5 we describe our code generation algorithm. This algorithm takes a mapping and produces optimized code corresponding to the transformation represented by that mapping. By making use of the gist operation [PW92] we are able to produce code with a smaller number of conditionals and loop bounds than would otherwise be necessary. Finally we discuss related work, give our implementation status and state our conclusions. 2 Dependences and Mappings Most of the previous work on program transformations uses ....

....without actually applying the transformation and re evaluating dependences. Since our framework includes loop fusion, they are not sufficient for our purposes either. We evaluate and represent dependences exactly using affine constraints over integer variables. We use the Omega Library [Pug92, PW92] to manipulate and simplify these constraints. The following is a brief description of integer tuple relations and dependence relations. 2.1 Integer tuple relations and sets An integer k tuple is simply a point in Z k . A tuple relation is a mapping from tuples to tuples. A single tuple may ....

[Article contains additional citation context not shown here]

William Pugh and David Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CSTR -3191, Dept. of Computer Science, University of Maryland, College Park, December 1992.

....the flow of information in the program being compiled; accurate information about this flow is critical for memory use optimizations. Array flow dependences in which the value written at the source is actually used at the sink of the dependence are referred to as value based flow dependences [PW92] or data flow dependences [May92, MAL93] Dependence tests that are based on only the first four of the above criteria are said to find memory based dependences [PW92] Data dependence testing is undecidable in general. Within the restricted domain described in Section 2, performing exact ....

.... the value written at the source is actually used at the sink of the dependence are referred to as value based flow dependences [PW92] or data flow dependences [May92, MAL93] Dependence tests that are based on only the first four of the above criteria are said to find memory based dependences [PW92] Data dependence testing is undecidable in general. Within the restricted domain described in Section 2, performing exact memory based array dependence testing is NP complete [Pug92] Paul Feautrier [Fea91] showed that performing exact value based dependence analysis of arrays within this ....

[Article contains additional citation context not shown here]

William Pugh and David Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-2993, Dept. of Computer Science, University of Maryland, College Park, December 1992. An earlier version of this paper appeared at the SIGPLAN PLDI'92 conference.

....(S 0 K) S K) convex hull ( fS1 ; Smg ) TupleSet represented by constraints f c j c part of S i 8 j=1: m(S j c) S j g Figure 2: Functions provided by the Omega Library tuples and a tuple set is a set of tuples. Tuple relations and sets are represented using the Omega Library [16, 18], which is a set of routines for manipulating affine constraints over integer variables. The relations and sets may involve symbolic constants such as n in the following example: f [i] i 1] j 1 i n g. They may also involve existentially quantified variables such as ff in the following ....

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.

....from tuples to tuples. The relations may involve free variables such as n in the following example: f [i] i 1] j 1 i n g. These free variables correspond to symbolic constants or parameters in the source program. Tuple relations and sets are represented using the Omega library [Pug92, PW95, PW93, KMP 95] which is a collection of routines for manipulating affine constraints over integer variables. The Omega library allows tuple relations and sets to be manipulated using operations such as intersection, union, inverse, composition, and difference. For example, for the simple form ....

William Pugh and David Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. IEEE Transactions on Parallel and Distributed Systems, pages 204--211, February 1995.

....finally refine the remaining dependences. 4.7 Efficiency We have measured the time needed to apply the tests described in this section to the flow dependences in several procedures. We have found that the average time needed per array access pair is under 1 ms on a SPARC IPX workstation ( PW92a, PW92b] 4.8 Related Work In analyzing false array flow data dependences (caused by output dependences) there are two basic approaches: ffl Extend the pair wise methods typically used for array data dependence to recognize array kills [Bra88, Rib90, Fea91, MAL92, MAL93] ffl Extend scalar dataflow ....

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.

....To do so, we introduce variables corresponding to these differences, and existentially quantify and eliminate all other variables. Alternatively, we can choose to eliminate everything but the symbolic constants, and thus determine the conditions under which the dependence exists ( PW92] Figure 3 shows a relatively complicated example of constraint based dependence analysis, from one of the NASA NAS benchmarks. Note that our techniques for eliminating equalities let us reduce both the number of variables and the number of constraints before resorting to Fourier elimination. ....

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.

....43: mark answer as conservative 44: endif 45: return Figure 1: The Epsilon test algorithm 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 affine 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 ....

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.

No context found.

W. Pugh and D. Wonnacott. Going beyond integer programming with the omega test to eliminate false data dependences. IEEE Transactions on Parallel and Distributed Systems, 6(2):204--211, Feb. 1995. 4.1.3

No context found.

W. Pugh and D. Wonnacott. Going beyond integer programming with the Omega test to eliminate false data dependences. Technical Report CS-TR-2993, Dept. of Computer Science, Univ. of Maryland, 1992.

No context found.

W. Pugh and D. Wonnacott. Going beyond integer programming with the omega test to eliminate false data dependences. IEEE Transactions on Parallel and Distributed Systems, 6(2):204--211, Feb. 1995. 4.1.3

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC