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.
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
accelerate-backend-kitSimplified internal AST to get going on writing backends
accelerate-buildbotBuild bot for automatic performance & regression testing
Install them from Hackage with
cabal install PACKAGENAME.
The following components are experimental and incomplete incomplete:
accelerate-llvmA framework for constructing backends targeting LLVM IR, with concrete backends for multicore CPUs and NVIDIA GPUs.
The following components are incomplete and not currently maintained. Please contact us if you are interested in working on them!
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:
email@example.com(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)