Paul R. Carini

Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects

We present practical approximation methods for computing interprocedural aliases and side effects for a program written in a language that includes pointers, reference parameters and recursion. We present the following results: 1) An algorithm for flow-sensitive interprocedural alias analysis which is more precise and efficient than the best interprocedural method known. 2) An extension of traditional flow-insensitive alias analysis which accommodates pointers and provides a framework for a family of algorithms which trade off precision for efficiency. 3) An algorithm which correctly computes side effects in the presence of pointers. Pointers cannot be correctly handled by conventional methods for side effect analysis. 4) An alias naming technique which handles dynamically allocated objects and guarantees the correctness of data-flow analysis. 5) A compact representation based on transitive reduction which does not result in a loss of precision and improves precision in some case. 6) A method for intraprocedural alias analysis which is based on a sparse representation.

Interprocedural pointer alias analysis

We present practical approximation methods for computing and representing interprocedural aliases for a program written in a language that includes pointers, reference parameters, and recursion. We present the following contributions: (1) a framework for interprocedural pointer alias analysis that handles function pointers by constructing the program call graph while alias analysis is being performed; (2) a flow-sensitive interprocedural pointer alias analysis algorithm; (3) a flow-insensitive interprocedural pointer alias analysis algorithm; (4) a flow-insensitive interprocedural pointer alias analysis algorithm that incorporates kill information to improve precision; (5) empirical measurements of the efficiency and precision of the three interprocedural alias analysis algorithms.

Flow-Insensitive Interprocedural Alias Analysis in the Presence of Pointers

Data-flow analysis algorithms can be classified into two categories: flow-sensitive and flow-insensitive. To improve efficiency, flow insensitive interprocedural analyses do not make use of the intraprocedural control flow information associated with individual procedures. Since pointer-induced aliases can change within a procedure, applying known flow-insensitive analyses can result in either incorrect or overly conservative solutions. In this paper, we present a flow-insensitive data flow analysis algorithm that computes interprocedural pointer-induced aliases. We improve the precision of our analysis by (1) making use of certain types of kill information that can be precomputed efficiently, and (2) computing aliases generated in each procedure instead of holding at the exit of each procedure. We improve the efficiency of our algorithm by introducing a technique called deferred evaluation.

Pointer-induced aliasing: a clarification

Recently, there has been an emphasis on analyzing programs in languages with pointers and recursive structures. A principal difficulty in developing these analyses appears to be incorporating the effects of pointer-induced aliasing. Two algorithms for general pointer-induced aliasing have recently been developed [LR92, CBC93]. This report clarifies discussions of this problem and the comparison between the two algorithms. 1 I n t r o d u c t i o n An access path [LH88] is constructed from variables, field selectors, and pointer dereferences. Two access paths X and Y are aliased at a program point P if on some execution pa th X and Y refer to the same address in memory. The aliasing problem determines a static approximation of dynamic aliases [Ban79]. There are two standard approximations: For each program point P, the MayAlias problem returns (an estimate for) the set of alias pairs which will hold at some instance of P in some execution history; the MustAlias problem returns (an estimate for) the set of alias pairs which hold at every instance of P in all execution instances. For the usual applications of these problems, an estimate is usable (safe) for MayAlias if it is certain to be art overestimate of MayAlias, and for MustAlias if it is art underestimate. Conversely, a solution is said to be precise up to symbolic execution if it returns only those alias pairs which will actually hold if some statically realizable p rogram path is taken. Any pa th through a procedure flow graph is realizable, and an interprocedural pa th is realizable if intraprocedurally it consists of realizable paths, and calls are correctly paired with returns [Hec77, JM82]. This is the usual assumption of compile-time analysis; however, the set of statically realizable program paths can be t r immed somewhat by propagation of Boolean conditions [WZ91]; such analyses are not included in the algorithms of [LR92, CBC93]. *Department of Mathematics and Computer Science, Seton Hall University, South Orange, NJ 07079; marlowe@cs, rutgers, edu tSiemens Corporate Research, 755 College Rd. East, Princeton, NJ 08540; blandi@siemens.com

Flow-sensitive interprocedural constant propagation

Department of Computer Science, Rutgers University, New Brunswick, NJ 08903; ryde r~cs . ru tge r s , edu ~Choi, Burke, and Carini are with IBM T.J. Watson Research Laboratory, PO Box 704, Yorktown Heights, NY 10598, burkem%wat son. ibm. tom, jdchoi~watson, ibm. com, carini%wat son. ibm. tom 67 ACM SIGPLAN Notices, Volume 28, No. 9, September 1993 The aliasing problem for scalar call-by-reference parameters, and its effects on the modificationside-effect problem (MOD), are well-understood and have well-established precise algoritluns fo r their solution [CK88, CK89, BM93] . Aliasing for pointers, particularly in the interprocedural do main, is a more difficult problem . Lan& has shown [Lan93] that precise MayAlias for general point ers is non-recursive, and precise MustAlias is non-computable (that is, non-recursively-enumerable) , even when all paths in the program are executable . Even when the MayAlias solution can be computed, precise algorithms are computationally intractable, and for recursive structures in a program with loops, precise solutions may require both infinite time and space . Proposed approximate algorithms are often incomparable, in both the precision and the cost of their solutions . The algorithms of [LR92, CBC93] collect alias information for a language allowing scalar variables, recursive structures, pointer variables, and parameters . They do not consider array variable s (arrays, if present, are treated as monolithic by the analysis) or procedure-valued parameters . To compare the storage requirements of the implementations of these algorithms is difficult . The implementation of the Landi-Ryder algorithm uses a flow graph reduction, comparable to that de scribed in [CBC93], but not described in [LR92] . Thus, worst case complexity comparisons base d on the implemented graph representations will be made in the future . The algorithms make us e of three dimensions of approximation: (i) depth of indirection traced (e .g ., k-limiting [JM82]), (ii ) summary of context (i .e ., the call stack), either by keeping part of the stack or information o n aliases passed along the path, and (iii) compaction of the current solution . Context is used to pai r calls and returns to refine the set of realizable paths, and to keep track of which aliases arrive d along particular call paths . Compaction allows aliases inferable from others to be kept implicitl y and reconstructed on demand . Refining in any one of these dimensions can provide more precis e solutions, although obviously at increased cost . Comparing the Two Alias Algorithm s The state-of-the-art for general pointer-induced aliasing (as opposed to aliasing or conflict detectio n within recursive structures alone [Lanni) consists of the Landi-Ryder algorithm [LR92] and a family of algorithms developed by Choi, Burke, and Carini [CBC93] . A fundamental difference betwee n the two algorithms is the means of recovering context . The Landi-Ryder algorithm uses assume d alias sets of size one ; refinements use call stack information . The Choi-Burke-Carini algoritlun s use call stack information of depth one and a transitive reduction compaction scheme . In addition , in [CBC93] techniques are presented for handling dynamically allocated objects . These methods are orthogonal to the aliasing algorithms and can just as well be used in the framework of other algorithms for pointer-induced alias analysis (such as [LR92]) . The complexity analysis given in [CBC93] is for the basic interprocedural algorithms . There ar e several sources of improved precision with respect to other methods ; however, it is not made clear in [CBC93] that some of these techniques gain precision in one form at the expense of losing it i n another form or incurring a cost in complexity . We now clarify these tradeoffs . • The algorithms in [CBC93], in using call stack information of depth one, do not in fact requir e the source alias set mechanism described there . The use of the source alias set mechanis m to support algorithmic refinements will be presented in [CBC93a] . Use of this mechanism t o retain stack information of unlimited depth would have exponential complexity . • The complexity analysis in [CBC93] does not include the handling of malloc sites . The technique described in the paper prefixes the site with a call stack string of length up to K ;

An empirical study of precise interprocedural array analysis

We present a flow-sensitive interprocedural constant propagation algorithm, which supports recursion while only performing one flow-sensitive analysis of each procedure. We present experimental results which show that this method finds substantially more constants than previous methods and is efficient in practice. We introduce new metrics for evaluating interprocedural constant propagation algorithms which measure the number of interprocedural constant values that are propagated. We use these metrics to provide further experimental results for our algorithm.

The classification, fusion, and parallelization of array language primitives

In this article we examine the role played by the interprocedural analysis of array accesses in the automatic parallelization of Fortran programs. We use the PTRAN system to provide measurements of several benchmarks to compare different methods of representing interprocedurally accessed arrays. We examine issues concerning the effectiveness of automatic parallelization using these methods and the efficiency of a precise summarization method.

A primitive-based strategy for producing efficient code for very high level programs

We present a classification scheme for array language primitives that quantifies the variation in parallelism and data locality that results from the fusion of any two primitives. We also present an algorithm based on this scheme that efficiently determines when it is beneficial to fuse any two primitives. Experimental results show that five LINPACK routines report 50% performance improvement from the fusion of array operators. >

Statement Merge: An Inter-Statement Optimization of Array Language Programs

This paper contrasts two very different strategies for improving the execution time performance of very high level language programs. An APL compiler has been developed which has two backends, one which produces IBM S/370 assembly code (APL/370) and one which produces C source code (APL/C). The result of each compilation path is compared for a large selection of APL benchmark programs. The results indicate that the efficient implementation of canned low level primitive routines can be a very effective optimization strategy for very high level languages.

System and method for identifying form type in a handwriting recognition based form completion system

Array language provides an effective paradigm for developing portable parallel programs but will only be used if compilers generate efficient code for array operations this paper presents an inter-statement optimization technique which merges related array operations in different statements. A merged statement creates opportunities for previously developed inter-primitive optimizations of array operators The potential advantages of statement merge are the elimination of a program variable, demand driven evaluation, reductions of data movement and loop overhead. The combination of statement merge and inter-primitive optimizations achieves a 3 8 fold execution time speedup in a scientific application