Proceedings Article10.1145/1596550.1596551
Organizing functional code for parallel execution or, foldl and foldr considered slightly harmful
Guy L. Steele
- 31 Aug 2009
- Vol. 44, Iss: 9, pp 1-2
29
TL;DR: This talk will discuss three ideas that I have found to be especially powerful in organizing Fortress programs so that they may be executed equally effectively either sequentially or in parallel: user-defined associative operators (and, more generally, user- defined monoids); conjugate transforms of data; and monoid-caching trees.
read more
Abstract: Alan Perlis, inverting OscarWilde's famous quip about cynics, once suggested, decades ago, that a Lisp programmer is one who knows the value of everything and the cost of nothing. Now that the conference on Lisp and Functional Programming has become ICFP, some may think that OCaml and Haskell programmers have inherited this (now undeserved) epigram.I do believe that as multicore processors are becoming prominent, and soon ubiquitous, it behooves all programmers to rethink their programming style, strategies, and tactics, so that their code may have excellent performance. For the last six years I have been part of a team working on a programming language, Fortress, that has borrowed ideas not only from Fortran, not only from Java, not only from Algol and Alphard and CLU, not only from MADCAP and MODCAP and MIRFAC and the Klerer-May system-but also from Haskell, and I would like to repay the favor.In this talk I will discuss three ideas (none original with me) that I have found to be especially powerful in organizing Fortress programs so that they may be executed equally effectively either sequentially or in parallel: user-defined associative operators (and, more generally, user-defined monoids); conjugate transforms of data; and monoid-caching trees (as described, for example, by Hinze and Paterson). I will exhibit pleasant little code examples (some original with me) that make use of these ideas.
read more
Chat with Paper
AI Agents for this Paper
Find similar papers on Google Scholar, PubMed and Arxiv
Write a critical review of this paper
Analyze citations of this paper to find unaddressed research gaps
Citations
Implicit Parallelism through Deep Language Embedding
Alexander Alexandrov,Andreas Kunft,Asterios Katsifodimos,Felix Schüler,Lauritz Thamsen,Odej Kao,Tobias Herb,Volker Markl +7 more
- 27 May 2015
TL;DR: This paper proposes a language for complex data analysis embedded in Scala, which allows for declarative specification of dataflows and hides the notion of data-parallelism and distributed runtime behind a suitable intermediate representation.
Higher-Order reactive programming with incremental lists
Ingo Maier,Martin Odersky +1 more
- 01 Jul 2013
TL;DR: This work presents a framework, Scala.React, with reactive abstractions for event streams, time-varying values as well as an incremental reactive list that automatically propagates incremental changes and guarantees strong data consistency.
47
A Survey of High-Level Parallel Programming Models
Evgenij Belikov,Pantazis Deligiannis,Prabhat Totoo,Malak Saleh Aljabri,Hans-Wolfgang Loidl +4 more
- 01 Jan 2013
TL;DR: The properties, advantages, and disadvantages of highlevel approaches to parallel programming that are deemed more exible for eciently utilising modern and future heterogeneous architectures are surveyed.
30
An algebra for distributed Big Data analytics
TL;DR: An algebra for data-intensive scalable computing based on monoid homomorphisms that consists of a small set of operations that capture most features supported by current domain-specific languages for data -centric distributed computing is presented.
29
Fork/join parallelism in the wild: documenting patterns and anti-patterns in Java programs using the fork/join framework
Mattias De Wael,Stefan Marr,Tom Van Cutsem +2 more
- 23 Sep 2014
TL;DR: An empirical study on a corpus of 120 open source Java projects that use the Fork/Join framework found three recurring anti-patterns that potentially limit parallel performance: sub-optimal use of Java collections when tasks into subtasks as well as when merging the results of subtasks, and finally the inappropriate sharing of resources between tasks.