An Embedded Language for Accelerated Array Computations
Data.Array.Accelerate defines an embedded language of array computations for high-performance computing in Haskell. Computations on multi-dimensional, regular arrays are expressed in the form of parameterised collective operations (such as maps, reductions, and permutations). These computations are online-compiled and executed on a range of architectures.
For more details, see our papers:
- Accelerating Haskell Array Codes with Multicore GPUs
- Optimising Purely Functional GPU Programs
- Embedding Foreign Code
There are also slides from some fairly recent presentations:
- Embedded Languages for High-Performance Computing in Haskell
- GPGPU Programming in Haskell with Accelerate (video) (workshop)
Chapter 6 of Simon Marlow's book Parallel and Concurrent Programming in Haskell contains a tutorial introduction to Accelerate.
Trevor's PhD thesis details the design and implementation of frontend optimisations and CUDA backend.
Table of Contents
- An Embedded Language for Accelerated Array Computations
A simple example
As a simple example, consider the computation of a dot product of two vectors of single-precision floating-point numbers:
dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float) dotp xs ys = fold (+) 0 (zipWith (*) xs ys)
Except for the type, this code is almost the same as the corresponding Haskell code on lists of floats. The types indicate that the computation may be online-compiled for performance — for example, using
Data.Array.Accelerate.CUDA.run it may be on-the-fly off-loaded to a GPU.
Package accelerate is available from
- Hackage: accelerate — install with
cabal install accelerate
- GitHub: AccelerateHS/accelerate - get the source with
git clone https://github.com/AccelerateHS/accelerate.git
The following supported addons are available as separate packages on Hackage and included as submodules in the GitHub repository:
accelerate-cudaBackend targeting CUDA-enabled NVIDA GPUs — requires the NVIDIA CUDA SDK and hardware with compute capability 1.2 or greater (see the table on Wikipedia)
accelerate-examplesComputational kernels and applications showcasing the use of Accelerate as well as a regression test suite (supporting function and performance testing)
accelerate-ioFast conversion between Accelerate arrays and other array formats (including Repa arrays)
accelerate-fftFast Fourier transform implementation, with optimised implementation for the CUDA backend
Install them from Hackage with
cabal install PACKAGENAME.
The following components are experimental and/or incomplete:
accelerate-llvmA framework for constructing backends targeting LLVM IR, with concrete backends for multicore CPUs and NVIDIA GPUs.
accelerate-backend-kitSimplified internal AST to get going on writing backends
The following components are incomplete or not currently maintained. Please contact us if you are interested in working on them!
accelerate-buildbotBuild bot for automatic performance & regression testing
accelerate-openclBackend targeting GPUs via the OpenCL standard
accelerate-repaBackend targeting multicore CPUs via the Repa parallel array library
- Glasgow Haskell Compiler (GHC), 7.8.3 or later
- For the CUDA backend, CUDA version 5.0 or later
- Haskell libraries as specified in the
- Haddock documentation is included in the package and linked from the Hackage page.
- Online documentation is on the GitHub wiki.
- The idea behind the HOAS (higher-order abstract syntax) to de-Bruijn conversion used in the library is described separately.
The GitHub repository contains a submodule accelerate-examples, which provides a range of computational kernels and a few complete applications. To install these from Hackage, issue
cabal install accelerate-examples. The examples include:
- An implementation of canny edge detection
- An interactive mandelbrot set generator
- An N-body simulation of gravitational attraction between solid particles
- An implementation of the PageRank algorithm
- A simple ray-tracer
- A particle based simulation of stable fluid flows
- A cellular automata simulation
- A "password recovery" tool, for dictionary lookup of MD5 hashes
Accelerate users have also built some substantial applications of their own. Please feel free to add your own examples!
- Henning Thielemann, patch-image: Combine a collage of overlapping images
- apunktbau, bildpunkt: A ray-marching distance field renderer
- klarh, hasdy: Molecular dynamics in Haskell using Accelerate
- Alexandros Gremm used Accelerate as part of the 2014 CSCS summer school (code)
Mailing list and contacts
- Mailing list:
firstname.lastname@example.org(discussions on both use and development are welcome)
- Sign up for the mailing list at the Accelerate Google Groups page.
- Bug reports and issues tracking: GitHub project page.
If you use Accelerate for academic research, you are encouraged (though not required) to cite the following papers (BibTeX):
Manuel M. T. Chakravarty, Gabriele Keller, Sean Lee, Trevor L. McDonell, and Vinod Grover. Accelerating Haskell Array Codes with Multicore GPUs. In DAMP '11: Declarative Aspects of Multicore Programming, ACM, 2011.
Trevor L. McDonell, Manuel M. T. Chakravarty, Gabriele Keller, and Ben Lippmeier. Optimising Purely Functional GPU Programs. In ICFP '13: The 18th ACM SIGPLAN International Conference on Functional Programming, ACM, 2013.
Robert Clifton-Everest, Trevor L. McDonell, Manuel M. T. Chakravarty, and Gabriele Keller. Embedding Foreign Code. In PADL '14: The 16th International Symposium on Practical Aspects of Declarative Languages, Springer-Verlag, LNCS, 2014.
Accelerate is primarily developed by academics, so citations matter a lot to us. As an added benefit, you increase Accelerate's exposure and potential user (and developer!) base, which is a benefit to all users of Accelerate. Thanks in advance!
Here is a list of features that are currently missing:
- Preliminary API (parts of the API may still change in subsequent releases)