accelerate (original) (raw)

accelerate: An embedded language for accelerated array processing

Data.Array.Accelerate defines an embedded array language for 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 may then be online compiled and executed on a range of architectures.

A simple example

As a simple example, consider the computation of a dot product of two vectors of 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, usingData.Array.Accelerate.LLVM.PTX it may be on-the-fly off-loaded to the GPU.

See the Data.Array.Accelerate module for further information.

Additional components

The following supported add-ons are available as separate packages. Use them by adding them as dependencies to your project's cabal file.

Additional libraries that have worked in the past but are not included in the current release (they may be updated later, check to be sure):

Examples and documentation

Haddock documentation is included in the package.

The accelerate-examples package demonstrates a range of computational kernels and several complete applications, including:

lulesh-accelerate is an implementation of the Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a typical hydrodynamics code such as ALE3D, but is highly simplified and hard-coded to solve the Sedov blast problem on an unstructured hexahedron mesh.

Mailing list and contacts

[Skip to Readme]

Modules

[Index] [Quick Jump]

Flags

Manual Flags

Name Description Default
debug Enable debug tracing messages.With debugging enabled, applications will read the following options from the environment variable ACCELERATE_FLAGS, and via the command-line as:./program +ACC ... -ACCNote that a backend may not implement (or be applicable to) all options.The following flags control phases of the compiler. The are enabled with-f and can be reversed with -fno-:acc-sharing: Enable sharing recovery of array expressions (True).exp-sharing: Enable sharing recovery of scalar expressions (True).fusion: Enable array fusion (True).inplace: Enable in-place array updates (True).force-recomp: Force recompilation of array programs (False).fast-math: Allow algebraically equivalent transformations which may change floating point results (e.g., reassociate) (True).fast-permute-const: Allow non-atomic `permute const` for product types (True).The following options control debug message output, and are enabled with-d.debug: Include debug symbols in the generated and compiled kernels.verbose: Be extra chatty.dump-phases: Print timing information about each phase of the compiler. Enable GC stats (+RTS -t or otherwise) for memory usage information.dump-sharing: Print information related to sharing recovery.dump-simpl-stats: Print statistics related to fusion & simplification.dump-simpl-iterations: Print a summary after each simplifier iteration.dump-vectorisation: Print information related to the vectoriser.dump-dot: Generate a representation of the program graph in Graphviz DOT format.dump-simpl-dot: Generate a more compact representation of the program graph in Graphviz DOT format. In particular, scalar expressions are elided.dump-gc: Print information related to the Accelerate garbage collector.dump-gc-stats: Print aggregate garbage collection information at the end of program execution.dump-cc: Print information related to kernel code generation/compilation. Print the generated code if verbose.dump-ld: Print information related to runtime linking.dump-asm: Print information related to kernel assembly. Print the assembled code if verbose.dump-exec: Print information related to program execution.dump-sched: Print information related to execution scheduling. Disabled
tracy Enable kernel profiling using Tracy. This flag requires +debug to also be set. Note: currently only works with accelerate-llvm-native; for PTX profiling, use Nvidia Nsight directly instead.The executables tracy (GUI) and 'tracy-capture' (command line) will be built to collect and view profiling data from supported backends. This requires several external dependencies:cmakepkg-configfreetype2glfw3gtk3 (linux only)TBB (should be part of your compiler toolchain)For example on Debian/Ubuntu you can install all of these via:sudo apt install cmake pkg-config libfreetype-dev libglfw3-dev libgtk-3-dev libtbb-devOr on macOS via:brew install cmake pkg-config freetype glfw Disabled
bounds-checks Enable bounds checking in the interpreter Enabled
internal-checks Enable some internal consistency checks Disabled
nofib Build the nofib test suite (required for backend testing) Disabled

Use -f to enable a flag, or -f - to disable that flag. More info

Downloads

Versions [RSS] 0.4.0, 0.5.0.0, 0.6.0.0, 0.7.1.0, 0.8.0.0, 0.8.1.0, 0.9.0.0, 0.9.0.1, 0.10.0.0, 0.12.0.0, 0.12.1.0, 0.12.2.0, 0.13.0.0, 0.13.0.1, 0.13.0.2, 0.13.0.3, 0.13.0.4, 0.13.0.5, 0.14.0.0, 0.15.0.0, 0.15.1.0, 1.0.0.0, 1.1.0.0, 1.1.1.0, 1.2.0.0, 1.2.0.1, 1.3.0.0, 1.4.0.0
Change log CHANGELOG.md
Dependencies accelerate, ansi-terminal (>=0.6.2), base (>=4.12 && <4.23), base-orphans (>=0.3), bytestring (>=0.10.2), containers (>=0.3), deepseq (>=1.3), directory (>=1.0), double-conversion (>=2.0), exceptions (>=0.6), filepath (>=1.0), formatting (>=7.0), ghc-prim, half (>=0.3), hashable (>=1.1), hashtables (>=1.2.3), hedgehog (>=0.5), microlens (>=0.4), mtl (>=2.0), prettyprinter (>=1.7), prettyprinter-ansi-terminal (>=1.1.2), primitive (>=0.6.4), tasty (>=0.11), template-haskell (<2.25), terminal-size (>=0.3), text (>=1.2.4), transformers (>=0.3), unique, unix, unordered-containers (>=0.2), vector (>=0.10), Win32 [details]
Tested with ghc >=8.6
License BSD-3-Clause
Author The Accelerate Team
Maintainer Trevor L. McDonell trevor.mcdonell@gmail.com
Uploaded by tomsmeding at 2026-04-02T16:43:06Z
Category Accelerate, Compilers/Interpreters, Concurrency, Data, Parallelism
Home page https://github.com/AccelerateHS/accelerate/
Bug tracker https://github.com/AccelerateHS/accelerate/issues
Source repo head: git clone https://github.com/AccelerateHS/accelerate.gitthis: git clone https://github.com/AccelerateHS/accelerate.git(tag v1.4.0.0)
Distributions
Reverse Dependencies 44 direct, 10 indirect [details]
Executables tracy-capture, tracy
Downloads 33922 total (41 in the last 30 days)
Rating 2.5 (votes: 6)[estimated by Bayesian average]
Your Rating λ λ λ
Status Docs available [build log]Last success reported on 2026-04-02 [all 1 reports]

Readme for accelerate-1.4.0.0

[back to package description]

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 presentations on Accelerate:

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

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.LLVM.PTX.run it may be on-the-fly off-loaded to a GPU.

Availability

Package Accelerate is available from:

To install the Haskell toolchain try GHCup.

Additional components

The following supported add-ons are available as separate packages:

These are all available on Hackage.

Documentation

Examples

accelerate-examples

The accelerate-examples package provides a range of computational kernels and a few complete applications. The examples include:

To run these, either get the source from Hackage using cabal get accelerate-examples or clone the git repository, then use cabal run on the individual executables.

Mandelbrot Raytracer

LULESH

LULESH-accelerate is in implementation of the Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a typical hydrodynamics code such as ALE3D, but is a highly simplified application, hard-coded to solve the Sedov blast problem on an unstructured hexahedron mesh.

LULESH mesh

Additional examples

Accelerate users have also built some substantial applications of their own. Please feel free to add your own examples!

Who are we?

The Accelerate team (past and present) consists of:

The maintainer and principal developer of Accelerate is Trevor L. McDonell trevor.mcdonell@gmail.com.

Citing Accelerate

If you use Accelerate for academic research, you are encouraged (though not required) to cite the following papers:

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!

What's missing?

Here is a list of features that are currently missing: