Lightweight concurrency primitives for GHC

Marlow, Simon; Jones, Simon Peyton; Tolmach, Andrew

doi:10.1145/1291201.1291217

Cited by 27 publications

(22 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Moreover, unlike our approach, the Par-monad is restricted to shared memory parallelism. Two separate lightweight implementations of concurrent Haskell have also been produced that lift scheduling and other concurrency features to the Haskell level (Li et al, 2007;Sivaramakrishnan et al, 2013). This complements our work, that instead focuses on the introduction and control of parallelism.…”

Section: Scheduling Support In Haskellmentioning

confidence: 75%

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide a portable and high-level shared-nothing implementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines. * Corresponding author. Reported work performed while at the University of Copenhagen (DIKU).

show abstract

Section: Scheduling Support In Haskellmentioning

confidence: 75%

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…One possible response, taken by Li et al [14] is to program these components, too, into Haskell. The difficulty is that all they are intricate and highly-optimised.…”

Section: The Challengementioning

confidence: 99%

Composable scheduler activations for Haskell

et al. 2016

Self Cite

View full text Add to dashboard Cite

The runtime for a modern, concurrent, garbage collected language like Java or Haskell is like an operating system: sophisticated, complex, performant, but alas very hard to change. If more of the runtime system were in the high level language, it would be far more modular and malleable. In this paper, we describe a novel concurrency substrate design for the Glasgow Haskell Compiler (GHC) that allows multicore schedulers for concurrent and parallel Haskell programs to be safely and modularly described as libraries in Haskell. The approach relies on abstracting the interface to the user-implemented schedulers through scheduler activations, together with the use of Software Transactional Memory (STM) to promote safety in a multicore context.

show abstract

“…The high-level language Erlang supports large numbers of lightweight threads running in parallel on a smaller number of worker threads [Hedqvist 1998], as does Haskell [Li et al 2007]. Pall's LuaJIT [Pall 2011], a JIT-compiled implementation of Lua, includes an interface between C and Lua coroutines containing a primitive similar to SWAPSTACK, implemented as inline assembly for GCC on the x86 architecture.…”

Section: Related Workmentioning

confidence: 99%

“…These constructs ease the programming of cooperating algorithms, like iteration over and processing of a complex datastructure's contents, or a lexer feeding tokens to a parser. Similarly, lightweight threads are found in Erlang [Hedqvist 1998], Haskell [Li et al 2007] and Go, where they are used to write more straightforward solutions to concur-rent problems like network servers or discrete event simulations, and to take advantage of multicore systems.…”

Section: Introductionmentioning

confidence: 99%

Compiler support for lightweight context switching

Dolan

Muralidharan

Gregg

2013

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

We propose a new language-neutral primitive for the LLVM compiler, which provides efficient context switching and message passing between lightweight threads of control. The primitive, called SWAPSTACK, can be used by any language implementation based on LLVM to build higher-level language structures such as continuations, co-routines, and lightweight threads. As part of adding the primitives to LLVM, we have also added compiler support for passing parameters across context switches. Our modified LLVM compiler produces highly efficient code through a combination of exposing the context switching code to existing compiler optimizations, and adding novel compiler optimizations to further reduce the cost of context switches. To demonstrate the generality and efficiency of our primitives, we add one-shot continuations to C++, and provide a simple fiber library that allows millions of fibers to run on multiple cores, with a work-stealing scheduler and fast inter-fiber sychronization. We argue that compiler-supported lightweight context switching can be significantly faster than using a library to switch between contexts, and provide experimental evidence to support the position.

show abstract

Lightweight concurrency primitives for GHC

Cited by 27 publications

References 23 publications

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Composable scheduler activations for Haskell

Compiler support for lightweight context switching

Contact Info

Product

Resources

About