Results 1 
6 of
6
A Naïve Time Analysis and its Theory of Cost Equivalence
 Journal of Logic and Computation
, 1995
"... Techniques for reasoning about extensional properties of functional programs are well understood, but methods for analysing the underlying intensional or operational properties have been much neglected. This paper begins with the development of a simple but useful calculus for time analysis of nons ..."
Abstract

Cited by 39 (7 self)
 Add to MetaCart
Techniques for reasoning about extensional properties of functional programs are well understood, but methods for analysing the underlying intensional or operational properties have been much neglected. This paper begins with the development of a simple but useful calculus for time analysis of nonstrict functional programs with lazy lists. One limitation of this basic calculus is that the ordinary equational reasoning on functional programs is not valid. In order to buy back some of these equational properties we develop a nonstandard operational equivalence relation called cost equivalence, by considering the number of computation steps as an `observable' component of the evaluation process. We define this relation by analogy with Park's definition of bisimulation in CCS. This formulation allows us to show that cost equivalence is a contextual congruence (and thus is substitutive with respect to the basic calculus) and provides useful proof techniques for establishing costequivalen...
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...
QDJanus: a Sequential Implementation of Janus in Prolog
 SoftwarePractice and Experience
, 1993
"... This paper describes QDJanus, a sequential implementation of Janus in Prolog. The compiler uses a number of novel analyses and optimizations to improve the performance of the system. The choice of Prolog as the target language for a compiler, although unusual, is motivated by the following: (i) the ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
This paper describes QDJanus, a sequential implementation of Janus in Prolog. The compiler uses a number of novel analyses and optimizations to improve the performance of the system. The choice of Prolog as the target language for a compiler, although unusual, is motivated by the following: (i) the semantic gap between Janus and Prolog is much smaller than that between Janus and, say, C or machine languagethis simplifies the compilation process significantly, and makes it possible to develop a system with reasonable performance fairly quickly; (ii) recent progress in Prolog implementation techniques, and the development of Prolog systems whose speeds are comparable to those of imperative languages, indicates that the translation to Prolog need not entail a significant performance loss compared to native code compilers; and (iii) compilation to Prolog can benefit immediately from a significant body of work on, and implementations of, parallel Prolog systems. Our experience indicates that translation of logic programming languages to Prolog, accompanied by the development of good program analysis and optimization tools, is an effective way to quickly develop flexible and portable implementations with good performance and low cost
Demand Transformation Analysis for Concurrent Constraint Programs
, 1994
"... Domain In this section we construct a domain of abstract constraints called ACon, which abstracts the domain #(C). In the construction of ACon, we use two domains called D and D V , also introduced in this section, which consist of nonground, downwardsclosed types representing sets of terms in #( ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Domain In this section we construct a domain of abstract constraints called ACon, which abstracts the domain #(C). In the construction of ACon, we use two domains called D and D V , also introduced in this section, which consist of nonground, downwardsclosed types representing sets of terms in #(H V ) and some basic types, such as the set of integers. (H V is ordered by t 1 t 2 if t 1 is a substitution instance of t 2 .) The domain of types is given by D ::= ? j? j j c(D; : : : ; D) j numj D D j :D. Program variables are not mentioned by types in D. In the syntax of D, c ranges over constructor symbols and is a fixpoint operator. Type variables are given by 2 TV , which are used only for fixpoint constructions. The base types ?, ? (read, "nonvar"), and num represent H V , H V n V , and the set of integers, respectively. Example 3.1. fX = ?; Y = ?g is an element of ACon representing the downwardsclosed set of constraints where X is constrained arbitrarily (including not at all...
Fast Strictness Analysis Based on Demand Propagation
 ACM Transactions on Programming Languages and Systems
, 1995
"... Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at lea ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at least one head undefined (value 2), and all lists (value 3). Burn's work [Burn 1987] on evaluation transformers also uses abstract interpretation on the abovementioned domain for strictness analysis. He defines four evaluators that correspond to the four points mentioned above in the sense that the ith evaluator will fail to produce an answer when given a list with the abstract value i \Gamma 1.
A New Framework for Strictness Analysis Using Demand Propagation
"... This paper presents a novel approach to strictness analysis called abstract demand propagation, approach developed for the implementation of lazy functional programming languages on parallel machines. Although some work on strictness analysis using demand propagation has been done before, the presen ..."
Abstract
 Add to MetaCart
This paper presents a novel approach to strictness analysis called abstract demand propagation, approach developed for the implementation of lazy functional programming languages on parallel machines. Although some work on strictness analysis using demand propagation has been done before, the present work is original in that it gives a precise interpretation of the notions of demands and demand propagation using an exact nonstandard denotational semantics. The intuition behind this semantics is that it represents a form of inverse computation, i.e., it determines the least amount of information needed to produce at least some required (demanded) result. Viewing demand propagation as a form of inverse computation allows to establish the soundness of our nonstandard semantics by formally relating it with the standard semantics. In order to define a compiletime analysis based on demand propagation, safety and termination must be ensured. This is done by defining an abstract interpreta...