Results 1  10
of
10
Fast Escape Analysis and Stack Allocation for ObjectBased Programs
, 2000
"... A fast and scalable interprocedural escape analysis algorithm is presented. The analysis computes a description of a subset of created objects whose lifetime is bounded by the lifetime of a runtime stack frame. The analysis results can be used for many purposes, including stack allocation of objects ..."
Abstract

Cited by 40 (0 self)
 Add to MetaCart
A fast and scalable interprocedural escape analysis algorithm is presented. The analysis computes a description of a subset of created objects whose lifetime is bounded by the lifetime of a runtime stack frame. The analysis results can be used for many purposes, including stack allocation of objects, thread synchronization elimination, deadstore removal, code motion, and iterator reduction. A method to use the analysis results for transforming a program to allocate some objects on the runtime stack is also presented. For nontrivial programs, typically 10%20% of all allocated objects are placed on the runtime stack after the transformation.
Type Analysis and Data Structure Selection
, 1991
"... Schwartz et al. described an optimization to implement builtin abstract types such as sets and maps with efficient data structures. Their transformation rests on the discovery of finite universal sets, called bases, to be used for avoiding data replication and for creating aggregate data structures ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
Schwartz et al. described an optimization to implement builtin abstract types such as sets and maps with efficient data structures. Their transformation rests on the discovery of finite universal sets, called bases, to be used for avoiding data replication and for creating aggregate data structures that implement associative access by simpler cursor or pointer access. The SETL implementation used global analysis similar to classical dataflow for typings and for set inclusion and membership relationships to determine bases. However, the optimized data structures selected by this optmization did not include a primitive linked list or array, and all optimized data structures retained some degree of hashing. Hence, this heuristic approach did not guarantee a uniform improvement in performance over the use of default representations. The analysis was complicated by SETL's imperative style, weak typing, and low level control structures. The implemented optimizer was large (about 20,000 line...
RealTime Deques, Multihead Turing Machines, and Purely Functional Programming
 In Conference on Functional Programming Languages and Computer Architecture
, 1993
"... We answer the following question: Can a deque (double ended queue) be implemented in a purely functional language such that each push or pop operation on either end of a queue is accomplished in O(1) time in the worst case? The answer is yes, thus solving a problem posted by Gajewska and Tarjan [1 ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
We answer the following question: Can a deque (double ended queue) be implemented in a purely functional language such that each push or pop operation on either end of a queue is accomplished in O(1) time in the worst case? The answer is yes, thus solving a problem posted by Gajewska and Tarjan [14] and by Ponder, McGeer, and Ng [25], and refining results of Sarnak [26] and Hoogerwoord [18]. We term such a deque realtime, since its constant worstcase behavior might be useful in real time programs (assuming realtime garbage collection [3], etc.) Furthermore, we show that no restriction of the functional language is necessary, and that push and pop operations on previous versions of a deque can also be achieved in constant time. We present a purely functional implementation of real time deques and its complexity analysis. We then show that the implementation has some interesting implications, and can be used to give a realtime simulation of a multihead Turing machine in a purel...
Solving Regular Tree Grammar Based Constraints
 In Proceedings of the 8th International Static Analysis Symposium
, 2000
"... This paper describes the precise specification, design, analysis, implementation, and measurements of an efficient algorithm for solving regular tree grammar based constraints. The particular constraints are for deadcode elimination on recursive data, but the method used for the algorithm design an ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
This paper describes the precise specification, design, analysis, implementation, and measurements of an efficient algorithm for solving regular tree grammar based constraints. The particular constraints are for deadcode elimination on recursive data, but the method used for the algorithm design and complexity analysis is general and applies to other program analysis problems as well. The method is centered around Paige's finite differencing, i.e., computing expensive set expressions incrementally, and allows the algorithm to be derived and analyzed formally and implemented easily. We study higherlevel transformations that make the derived algorithm concise and allow its complexity to be analyzed accurately. Although a rough analysis shows that the worstcase time complexity is cubic in program size, an accurate analysis shows that it is linear in the number of live program points and in other parameters, including mainly the arity of data constructors and the number of selector applications into whose arguments the value constructed at a program point might flow. These parameters explain the performance of the analysis in practice. Our implementation also runs two to ten times as fast as a previous implementation of an informally designed algorithm.
Fully Persistent Arrays for Efficient Incremental Updates and Voluminous Reads
 4th European Symposium on Programming
, 1992
"... The array update problem in a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. We devise a very simple, fully persistent data structure to tackle this problem such that ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
The array update problem in a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. We devise a very simple, fully persistent data structure to tackle this problem such that ffl each incremental update costs O(1) worstcase time, ffl a voluminous sequence of r reads cost in total O(r) amortized time, and ffl the data structure use O(n + u) space, where n is the size of the array and u is the total number of updates. A sequence of r reads is voluminous if r is \Omega\Gamma n) and the sequence of arrays being read forms a path of length O(r) in the version tree. A voluminous sequence of reads may be mixed with updates without affecting either the performance of reads or updates. An immediate consequence of the above result is that if a functional program is singlethreaded, then the data structure provides a simple and efficient implementation of funct...
Optimizing Fortran 90 Shift Operations on DistributedMemory Multicomputers
, 1995
"... When executing Fortran 90 style dataparallel array operations on distributedmemory multiprocessors, intraprocessor data movement due to shift operations can account for a signicant fraction of the execution time. This paper describes a strategy for minimizing data movement caused by Fortran 90 ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
When executing Fortran 90 style dataparallel array operations on distributedmemory multiprocessors, intraprocessor data movement due to shift operations can account for a signicant fraction of the execution time. This paper describes a strategy for minimizing data movement caused by Fortran 90 CSHIFT operations and presents a compiler technique that exploits this strategy automatically. The compiler technique is global in scope and can reduce data movement even when a denition of an array and its uses are separated by control ow. This technique supersedes those whose scope is restricted to a single statement. We focus on the application of this strategy on distributedmemory architectures, although it is more broadly applicable.
Optimizing Fortran90D/HPF for DistributedMemory Computers
, 1997
"... High Performance Fortran (HPF), as well as its predecessor FortranD, has attracted considerable attention as a promising language for writing portable parallel programs for a wide variety of distributedmemory architectures. Programmers express data parallelism using Fortran90 array operations and u ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
High Performance Fortran (HPF), as well as its predecessor FortranD, has attracted considerable attention as a promising language for writing portable parallel programs for a wide variety of distributedmemory architectures. Programmers express data parallelism using Fortran90 array operations and use data layout directives to direct the partitioning of the data and computation among the processors of a parallel machine. For HPF to gain acceptance as a vehicle for parallel scientific programming, it must achieve high performance on problems for which it is well suited. To achieve high performance with an HPF program on a distributedmemory parallel machine, an HPF compiler must do a superb job of translating Fortran90 dataparallel array constructs into an efficient sequence of operations that minimize the overhead associated with data movement and also maximize data locality. This dissertation presents and analyzes a set of advanced optimizations designed to improve the execution perf...
Semantic Analyses for Storage Management Optimizations in Functional Language Implementations
, 1991
"... One of the major overheads in implementing functional languages is the storage management overhead due to dynamic allocation and automatic reclamation of indefiniteextent storage. This dissertation investigates the problems of statically inferring lifetime information about dynamicallyallocated ob ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
One of the major overheads in implementing functional languages is the storage management overhead due to dynamic allocation and automatic reclamation of indefiniteextent storage. This dissertation investigates the problems of statically inferring lifetime information about dynamicallyallocated objects in higherorder polymorphic functional languages, both strict and nonstrict, and of applying that information to reduce the storage management overhead. We have developed a set of compiletime semantic analyses for a higherorder, monomorphic, strict functional language based on denotational semantics and abstract interpretation. They are 1) escape analysis, which provides information about the relative lifetimes of objects such as arguments and local objects defin...
Optimizing Fortran 90 Shift Operations on DistributedMemory Multicomputers
, 1995
"... When executing Fortran 90 style dataparallel array operations on distributedmemory multiprocessors, intraprocessor data movement due to shift operations can account for a signicant fraction of the execution time. This paper describes a strategy for minimizing data movement caused by Fortran 90 ..."
Abstract
 Add to MetaCart
When executing Fortran 90 style dataparallel array operations on distributedmemory multiprocessors, intraprocessor data movement due to shift operations can account for a signicant fraction of the execution time. This paper describes a strategy for minimizing data movement caused by Fortran 90 CSHIFT operations and presents a compiler technique that exploits this strategy automatically. The compiler technique is global in scope and can reduce data movement even when a denition of an array and its uses are separated by control ow. This technique supersedes those whose scope is restricted to a single statement. We focus on the application of this strategy on distributedmemory architectures, although it is more broadly applicable. 1