Parallelism in sequential functional languages

Blelloch, Guy E.; Greiner, John

doi:10.1145/224164.224210

Cited by 67 publications

(54 citation statements)

References 37 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The present work extends the methodology of Blelloch and Greiner [4,13] to account for the cache complexity of algorithms stated in terms of two parameters, the cache block size and the number of cache blocks. Analyses are carried out in terms of the semantics of ICFP given in Section 2, and are transferred to the Ideal Cache Model by a provable implementation, also sketched in Section 2.…”

Section: Resultsmentioning

confidence: 99%

“…The general idea of using high-level cost models based on a cost semantics along with a provable efficient implementation has previously been used in the context of parallel cost models [4,13,22,15]. Although there has been a large amount of experimental work on showing how good garbage collection can lead to efficient use of caches and disks ( [10,24,14,7] and many references in [16]), we know of none that try to prove bounds for algorithms for functional programs when manipulating recursive data types such as lists or trees.…”

Section: Related Workmentioning

confidence: 99%

“…The abstract cost semantics underlies the analyses given in Sections 1 and 3. The abstract costs given by the semantics are validated by giving a provable implementation [4,13] that realizes these costs on a concrete machine. In our case the realization is given in terms of the ICMM, which is an accepted concrete formulation of a machine with hierarchical memory.…”

Section: So We Consider An Evaluation Relation Of the Formmentioning

confidence: 99%

See 2 more Smart Citations

Cache efficient functional algorithms

Blelloch

Harper

2015

Commun. ACM

View full text Add to dashboard Cite

The widely studied I/O and ideal-cache models were developed to account for the large difference in costs to access memory at different levels of the memory hierarchy. Both models are based on a two level memory hierarchy with a fixed size fast memory (cache) of size M , and an unbounded slow memory organized in blocks of size B. The cost measure is based purely on the number of block transfers between the primary and secondary memory. All other operations are free. Many algorithms have been analyzed in these models and indeed these models predict the relative performance of algorithms much more accurately than the standard RAM model. The models, however, require specifying algorithms at a very low level, requiring the user to carefully lay out their data in arrays in memory and manage their own memory allocation.We present a cost model for analyzing the memory efficiency of algorithms expressed in a simple functional language. We show how some algorithms written in standard forms using just lists and trees (no arrays) and requiring no explicit memory layout or memory management are efficient in the model. We then describe an implementation of the language and show provable bounds for mapping the cost in our model to the cost in the ideal-cache model. These bounds imply that purely functional programs based on lists and trees with no special attention to any details of memory layout can be asymptotically as efficient as the carefully designed imperative I/O efficient algorithms. For example we describe an O( n B log M/B n B ) cost sorting algorithm, which is optimal in the ideal cache and I/O models.

show abstract

Section: Resultsmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: So We Consider An Evaluation Relation Of the Formmentioning

confidence: 99%

See 1 more Smart Citation

Cache efficient functional algorithms

Blelloch

Harper

2015

Commun. ACM

View full text Add to dashboard Cite

show abstract

“…Since the work of Blelloch and Greiner [17], it is known that the number of β-steps in the call-by-value closed λ-calculus can indeed be considered as a reasonable cost model. Roughly, one can consider β as an (almost) atomic operation, counting 1 (actually a cost bound by the size of the initial term) for each step.…”

Section: Introductionmentioning

confidence: 99%

The Negligible and Yet Subtle Cost of Pattern Matching

Accattoli

Barras

2017

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. The model behind functional programming languages is the closed λ-calculus, that is, the fragment of the λ-calculus where evaluation is weak (i.e. out of abstractions) and terms are closed. It is well-known that the number of β (i.e. evaluation) steps is a reasonable cost model in this setting, for all natural evaluation strategies (call-by-name / value / need). In this paper we try to close the gap between the closed λ-calculus and actual languages, by considering an extension of the λ-calculus with pattern matching. It is straightforward to prove that β plus matching steps provide a reasonable cost model. What we do then is finer: we show that β steps only, without matching steps, provide a reasonable cost model also in this extended setting-morally, pattern matching comes for free, complexity-wise. The result is proven for all evaluation strategies (name / value / need), and, while the proof itself is simple, the problem is shown to be subtle. In particular we show that qualitatively equivalent definitions of call-by-need may behave very differently.This work is part of a wider research effort, the COCA HOLA project [3].

show abstract

“…Danielsson [13] does this. The cost of constructing and looking up the environment of a closure is not a problem: as noted by Blelloch and Greiner [5], it is a constant, which depends on the number of variables in the program.…”

Section: Introductionmentioning

confidence: 99%

Machine-Checked Verification of the Correctness and Amortized Complexity of an Efficient Union-Find Implementation

Charguéraud

Pottier

2015

Interactive Theorem Proving

View full text Add to dashboard Cite

Abstract. Union-Find is a famous example of a simple data structure whose amortized asymptotic time complexity analysis is non-trivial. We present a Coq formalization of this analysis. Moreover, we implement Union-Find as an OCaml library and formally endow it with a modular specification that offers a full functional correctness guarantee as well as an amortized complexity bound. Reasoning in Coq about imperative OCaml code relies on the CFML tool, which is based on characteristic formulae and Separation Logic, and which we extend with time credits. Although it was known in principle that amortized analysis can be explained in terms of time credits and that time credits can be viewed as resources in Separation Logic, we believe our work is the first practical demonstration of this approach.

show abstract

Parallelism in sequential functional languages

Abstract: This paper formally studies the question of how much paral-

Cited by 67 publications

References 37 publications

Cache efficient functional algorithms

Cache efficient functional algorithms

The Negligible and Yet Subtle Cost of Pattern Matching

Machine-Checked Verification of the Correctness and Amortized Complexity of an Efficient Union-Find Implementation

Contact Info

Product

Resources

About