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:

There are also slides from some fairly recent presentations:

Chapter 6 of Simon Marlow's book Parallel and Concurrent Programming in Haskell contains a tutorial introduction to Accelerate.

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.

Availability

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

Additional components

The following supported addons are available as separate packages on Hackage and included as submodules in the GitHub repository:

accelerate-cuda Backend 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-examples Computational kernels and applications showcasing the use of Accelerate as well as a regression test suite (supporting function and performance testing)
accelerate-io Fast conversion between Accelerate arrays and other array formats (including Repa arrays)
accelerate-backend-kit Simplified internal AST to get going on writing backends
accelerate-buildbot Build bot for automatic performance & regression testing

Install them from Hackage with cabal install PACKAGENAME.

The following additional components are experimental and incomplete:

accelerate-opencl Backend targeting GPUs via the OpenCL standard
accelerate-repa Backend targeting multicore CPUs via the Repa parallel array library

Requirements

Glasgow Haskell Compiler (GHC), 7.6 or later
Haskell libraries as specified in accelerate.cabal
For the CUDA backend, CUDA version 3.0 or later

Examples and documentation

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.

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.

Mailing list and contacts

Mailing list: accelerate-haskell@googlegroups.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.

The maintainers of Accelerate are Manuel M T Chakravarty chak@cse.unsw.edu.au and Trevor L McDonell tmcdonell@cse.unsw.edu.au.

What's missing?

Here is a list of features that are currently missing:

Preliminary API (parts of the API may still change in subsequent releases)

alsam/accelerate