Results 1  10
of
26
Domain Theory
 Handbook of Logic in Computer Science
, 1994
"... Least fixpoints as meanings of recursive definitions. ..."
Abstract

Cited by 461 (20 self)
 Add to MetaCart
Least fixpoints as meanings of recursive definitions.
Escape Analysis on Lists
 In Proceedings of the SIGPLAN '92 Conference on Program Language Design and Implementation
, 1992
"... Higher order functional programs constantly allocate objects dynamically. These objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. This paper describes a compile time analysis, called escape analysis ..."
Abstract

Cited by 57 (0 self)
 Add to MetaCart
Higher order functional programs constantly allocate objects dynamically. These objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. This paper describes a compile time analysis, called escape analysis, for determining the lifetime of dynamically created objects in higher order functional programs, and describes optimizations that can be performed, based on the analysis, to improve storage allocation and reclamation of such objects. In particular, our analysis can be applied to programs manipulating lists, in which case optimizations can be performed to allow whole cons cells in spines of lists to be either reclaimed at once or reused without incurring any garbage collection overhead. In a previous paper on escape analysis [10], we had left open the problem of performing escape analysis on lists. Escape analysis simply determines when the argument (or some part of the argument) to a func...
Strictness Analysis on NonFlat Domains (by Abstract Interpretation over Finite Domains)
 Abstract Interpretation of Declarative Languages
"... Interpretation over Finite Domains) Philip Wadler Programming Research Group Oxford University Recent work shows that lazy functional languages can be compiled to run on conventional architectures with very good speed [Johnsson 84, PeytonJones 86]. Strictness analysis is one way to make such impl ..."
Abstract

Cited by 52 (1 self)
 Add to MetaCart
Interpretation over Finite Domains) Philip Wadler Programming Research Group Oxford University Recent work shows that lazy functional languages can be compiled to run on conventional architectures with very good speed [Johnsson 84, PeytonJones 86]. Strictness analysis is one way to make such implementations even faster. This is because when an argument to a function is known to be strict then one may evaluate the argument directly rather than build a data structure to be evaluated later. One of the most promising techniques of strictness analysis is by abstract interpretation [Mycroft 83], which recently has been extended to include higherorder functions [Burn et al 85, Hudak and Young 85, 86] and polymorphism [Abramsky 85]. One of the remaining problems of great interest is whether this method can be extended to nonflat domains. Accordingly, strictness analysis on nonflat domains has received a great deal of attention [Hughes 85, Karlsson 85, Kieburtz 85]. Unfortunately, the wor...
Parallel Programming using Functional Languages
, 1991
"... I am greatly indebted to Simon Peyton Jones, my supervisor, for his encouragement and technical assistance. His overwhelming enthusiasm was of great support to me. I particularly want to thank Simon and Geoff Burn for commenting on earlier drafts of this thesis. Through his excellent lecturing Cohn ..."
Abstract

Cited by 48 (3 self)
 Add to MetaCart
I am greatly indebted to Simon Peyton Jones, my supervisor, for his encouragement and technical assistance. His overwhelming enthusiasm was of great support to me. I particularly want to thank Simon and Geoff Burn for commenting on earlier drafts of this thesis. Through his excellent lecturing Cohn Runciman initiated my interest in functional programming. I am grateful to Phil Trinder for his simulator, on which mine is based, and Will Partain for his help with LaTex and graphs. I would like to thank the Science and Engineering Research Council of Great Britain for their financial support. Finally, I would like to thank Michelle, whose culinary skills supported me whilst I was writingup.The Imagination the only nation worth defending a nation without alienation a nation whose flag is invisible and whose borders are forever beyond the horizon a nation whose motto is why have one or the other when you can have one the other and both
Strictness logic and polymorphic invariance
 In Proc. Logical Found. Comp. Sci
, 1992
"... We describe a logic for reasoning about higherorder strictness properties of typed lambda terms. The logic arises from axiomatising the inclusion order on certain closed subsets of domains. The axiomatisation of the lattice of strictness properties is shown to be sound and complete, and we then giv ..."
Abstract

Cited by 16 (2 self)
 Add to MetaCart
We describe a logic for reasoning about higherorder strictness properties of typed lambda terms. The logic arises from axiomatising the inclusion order on certain closed subsets of domains. The axiomatisation of the lattice of strictness properties is shown to be sound and complete, and we then give a program logic for assigning properties to terms. This places work on strictness analysis via type inference on a firm theoretical foundation. We then use proof theoretic techniques to show how the derivable strictness properties of different instances of polymorphically typed terms are related. 1
Code optimizations for lazy evaluation
 LISP and Symbolic Computation
, 1988
"... Implementations of lazy evaluation for nonstrict functional languages usually involve the notion of a delayed representation of the value of an expression, which we call a thunk. We present several techniques for implementing thunks and formalize a class of optimizations that reduce both the space ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
Implementations of lazy evaluation for nonstrict functional languages usually involve the notion of a delayed representation of the value of an expression, which we call a thunk. We present several techniques for implementing thunks and formalize a class of optimizations that reduce both the space and time overhead of these techniques. The optimizations depend on a compiletime inferencing strategy called path analysis, a generalization of strictness analysis that uncovers orderofevaluation information. Although the techniques in this paper are focused on the compilation of a nonstrict functional language for a conventional architecture, they are directly applicable to most of the virtual machines commonly used for implementing such languages. The same techniques also apply to other forms of delayed evaluation such as futures and promises. 1
Some directed graph algorithms and their application to pointer analysis (work in progress
, 2004
"... This thesis is focused on improving execution time and precision of scalable pointer analysis. Such an analysis statically determines the targets of all pointer variables in a program. We formulate the analysis as a directed graph problem, where the solution can be obtained by a computation similar, ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
This thesis is focused on improving execution time and precision of scalable pointer analysis. Such an analysis statically determines the targets of all pointer variables in a program. We formulate the analysis as a directed graph problem, where the solution can be obtained by a computation similar, in many ways, to transitive closure. As with transitive closure, identifying strongly connected components and transitive edges offers significant gains. However, our problem differs as the computation can result in new edges being added to the graph and, hence, dynamic algorithms are needed to efficiently identify these structures. Thus, pointer analysis has often been likened to the dynamic transitive closure problem. Two new algorithms for dynamically maintaining the topological order of a directed graph are presented. The first is a unit change algorithm, meaning the solution must be recomputed immediately following an edge insertion. While this has a marginally inferior worsecase time bound, compared with a previous solution, it is far simpler to implement and has fewer restrictions. For these reasons, we find it to be faster in practice and provide an experimental study over random graphs to support this. Our second is a batch algorithm, meaning the solution can be updated after
Games in the Semantics of Programming Languages
 Dept. of Philosophy, University of Amsterdam
, 1997
"... ion for PCF Motivated by the full completeness results, it became of compelling interest to reexamine perhaps the bestknown "open problem" in the semantics of programming languages, namely the "Full Abstraction problem for PCF", using the new tools provided by game semantics. 2 PCF is a highero ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
ion for PCF Motivated by the full completeness results, it became of compelling interest to reexamine perhaps the bestknown "open problem" in the semantics of programming languages, namely the "Full Abstraction problem for PCF", using the new tools provided by game semantics. 2 PCF is a higherorder functional programming language; modulo issues of the parameterpassing strategies, it forms a fragment of any programming language with higherorder procedures (which includes any reasonably expressive objectoriented language). The aspect of the Full Abstraction problem I personally found most interesting was: to construct a syntaxindependent model in which every element is the denotation of some program (note the analogy with full completeness, whose definition had in turn been motivated in part by this aspect of full abstraction). This is not how the problem was originally formulated, but by "general abstract nonsense", given such a model one can always quotient it to get a fully ab...
On the Safety of Nöcker’s Strictness Analysis
 FRANKFURT AM MAIN, GERMANY
"... Abstract. This paper proves correctness of Nöcker’s method of strictness analysis, implemented for Clean, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work of Clark, Hankin and Hunt, which addresses correctne ..."
Abstract

Cited by 8 (7 self)
 Add to MetaCart
Abstract. This paper proves correctness of Nöcker’s method of strictness analysis, implemented for Clean, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work of Clark, Hankin and Hunt, which addresses correctness of the abstract reduction rules. Our method also addresses the cycle detection rules, which are the main strength of Nöcker’s strictness analysis. We reformulate Nöcker’s strictness analysis algorithm in a higherorder lambdacalculus with case, constructors, letrec, and a nondeterministic choice operator ⊕ used as a union operator. Furthermore, the calculus is expressive enough to represent abstract constants like Top or Inf. The operational semantics is a smallstep semantics and equality of expressions is defined by a contextual semantics that observes termination of expressions. The correctness of several reductions is proved using a context lemma and complete sets of forking and commuting diagrams.
The Impact of Laziness on Parallelism and the Limits of Strictness Analysis
 PROCEEDINGS HIGH PERFORMANCE FUNCTIONAL COMPUTING
, 1995
"... The major question examined by this paper is whether sufficient finegrain parallelism can be obtained from programs written in a lazy functional language. To answer this question, we have implemented a prototype compiler based on a novel approach to strictness analysis (called abstract demand propa ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
The major question examined by this paper is whether sufficient finegrain parallelism can be obtained from programs written in a lazy functional language. To answer this question, we have implemented a prototype compiler based on a novel approach to strictness analysis (called abstract demand propagation) and we have compared this implementation strategy (optimized lazy) with other implementations, viz., pure lazy and lenient. Although the optimized lazy implementation improves significantly the efficiency of the resulting programs over the pure lazy approach, it was found that little parallelism can effectively be identified. This remains true even when a new notion of laziness  speculative laziness  is introduced, notion well suited to parallel machines as it based on a parallel notion of headstrictness instead of the traditional sequential one. Our experiments also showed that when a program's result is known to be finite, then strictness analysis can generate almost as mu...