Results 1  10
of
22
Task Granularity Analysis in Logic Programs
, 1990
"... While logic programming languages o#er a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the w ..."
Abstract

Cited by 63 (28 self)
 Add to MetaCart
While logic programming languages o#er a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.
A Methodology for Granularity Based Control of Parallelism in Logic Programs
 Journal of Symbolic Computation, Special Issue on Parallel Symbolic Computation
, 1996
"... ..."
Heap Profiling of Lazy Functional Programs
, 1992
"... We describe the design, implementation and use of a new kind of profiling tool that yields valuable information about the memory use of lazy functional programs. The tool has two parts: a modified functional language implementation which generates profiling information during the execution of progra ..."
Abstract

Cited by 49 (10 self)
 Add to MetaCart
We describe the design, implementation and use of a new kind of profiling tool that yields valuable information about the memory use of lazy functional programs. The tool has two parts: a modified functional language implementation which generates profiling information during the execution of programs, and a separate program which converts this information to graphical form. With the aid of profile graphs, one can make alterations to a functional program which dramatically reduce its space consumption. We demonstrate this in the case of a genuine example the first to which the tool was applied for which the results are strikingly successful. Capsule review Profiling technology for lazy functional programs is long overdue. Runciman and Wakeling have produced a practical and useful tool, notably because it works in the context of a fullyfledged compiler. Their work highlights the lack of information we have about the dynamic behaviour of lazy functional programs and the potential performance improvements which may be possible given profiling tools to provide us with it. This paper opens up new areas of practical research designing and building such tools. Runciman and Wakeling have started this work with the design and implementation of a heap profiling tool. They place considerable emphasis on the design of an appropriate graphical presentation of the large quantity of profiling data produced. It is interesting that they profile space and not time; ideally one would like both. An upper bound on execution time improvements from improving space behaviour is the garbage collection and paging time. However, they found that the task of fixing space bugs does sometimes lead to beneficial algorithmic changes too. We await with interest the continued development of practical profiling tools for lazy functional programs. 1
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
Complexity Analysis for a Lazy HigherOrder Language
 In Proceedings of the 3rd European Symposium on Programming
, 1990
"... This paper is concerned with the timeanalysis of functional programs. Techniques which enable us to reason formally about a program's execution costs have had relatively little attention in the study of functional programming. We concentrate here on the construction of equations which compute t ..."
Abstract

Cited by 47 (2 self)
 Add to MetaCart
This paper is concerned with the timeanalysis of functional programs. Techniques which enable us to reason formally about a program's execution costs have had relatively little attention in the study of functional programming. We concentrate here on the construction of equations which compute the timecomplexity of expressions in a lazy higherorder language. The problem with higherorder functions is that complexity is dependent on the cost of applying functional parameters. Structures called costclosures are introduced to allow us to model both functional parameters and the cost of their application. The problem with laziness is that complexity is dependent on context. Projections are used to characterise the context in which an expression is evaluated, and costequations are parameterised by this contextdescription to give a compositional timeanalysis. Using this form of context information we introduce two types of timeequation: sufficienttime equations and nece...
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...
A sized time system for a parallel functional language
 In Proc. Implementation of Functional Langs.(IFL ’02
, 2003
"... This paper describes an inference system, whose purpose is to determine the cost of evaluating expressions in a strict purely functional language. Upper bounds can be derived for both computation cost and the size of data structures. We outline a static analysis based on this inference system for in ..."
Abstract

Cited by 24 (14 self)
 Add to MetaCart
This paper describes an inference system, whose purpose is to determine the cost of evaluating expressions in a strict purely functional language. Upper bounds can be derived for both computation cost and the size of data structures. We outline a static analysis based on this inference system for inferring size and cost information. The analysis is a synthesis of the sized types of Hughes et al., and the polymorphic time system of Dornic et al., which was extended to static dependent costs by Reistad and Gifford. Our main interest in cost information is for scheduling tasks in the parallel execution of functional languages. Using the GranSim parallel simulator, we show that the information provided by our analysis is sufficient to characterise relative task granularities for a simple functional program. This information can be used in the runtimesystem of the Glasgow Parallel Haskell compiler to improve dynamic program performance. 1
Parallelism in sequential functional languages
 PROC. OF THE INT. CONF. ON
, 1995
"... This paper formally studies the question of how much parallelism is available in calbyvalue functional languages with no parallel extensions (i. e., the functional sub;ets of ML or Scheme). In particular we are interested in placing bounds on how much parallelism is available for various problems. ..."
Abstract

Cited by 16 (7 self)
 Add to MetaCart
This paper formally studies the question of how much parallelism is available in calbyvalue functional languages with no parallel extensions (i. e., the functional sub;ets of ML or Scheme). In particular we are interested in placing bounds on how much parallelism is available for various problems. To do this we introduce a complexity model, the PAL, based on the callbyvalue Acalculus. The model is defined in terms of a profiling semantics and measures complexity in terms of the total work and the parallel depth of a computation. We describe a simulation of the APAL (the PAL extended with arithmetic operations) on various parallel machine models, including the butterfly, hypercube, and PRAM models and prove simulation bounds. In particular the simulat ions are work eficient (the processortime product on the machines is within a constant factor of the work on the APAL), and for p processors the slowdown (time on the machines divided by depth on the APAL) is proportional to at most O(log p). We also prove bounds for simulating the PRAM on the APAL. Based on the model, we describe and analyze treebased versions of quicksort and merge sort. We show that for an input of size n these algorithms run on the APAL model with O(rI log n) work and 0(log² n) depth (expected case for quicksort).
The Role of Lazy Evaluation in Amortized Data Structures
 In Proc. of the International Conference on Functional Programming
, 1996
"... Traditional techniques for designing and analyzing amortized data structures in an imperative setting are of limited use in a functional setting because they apply only to singlethreaded data structures, yet functional data structures can be nonsinglethreaded. In earlier work, we showed how lazy e ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
Traditional techniques for designing and analyzing amortized data structures in an imperative setting are of limited use in a functional setting because they apply only to singlethreaded data structures, yet functional data structures can be nonsinglethreaded. In earlier work, we showed how lazy evaluation supports functional amortized data structures and described a technique (the banker's method) for analyzing such data structures. In this paper, we present a new analysis technique (the physicist's method) and show how one can sometimes derive a worstcase data structure from an amortized data structure by appropriately scheduling the premature execution of delayed components. We use these techniques to develop new implementations of FIFO queues and binomial queues. 1 Introduction Functional programmers have long debated the relative merits of strict versus lazy evaluation. Although lazy evaluation has many benefits [11], strict evaluation is clearly superior in at least one area:...
Calculating Lenient Programs' Performance
 Functional Programming, Glasgow 1990, Workshops in computing
, 1990
"... Lenient languages, such as Id Nouveau, have been proposed for programming parallel computers. These languages represent a compromise between strict and lazy languages. The operation of parallel languages is very complex; therefore a formal method for reasoning about their performance is desirable. T ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
Lenient languages, such as Id Nouveau, have been proposed for programming parallel computers. These languages represent a compromise between strict and lazy languages. The operation of parallel languages is very complex; therefore a formal method for reasoning about their performance is desirable. This paper presents a nonstandard denotational semantics for calculating the performance of lenient programs. The semantics is novel in its use of time and timestamps.