accelerate: An embedded language for accelerated array processing

[ accelerate, bsd3, compilers-interpreters, concurrency, data, library, parallelism ] [ Propose Tags ]

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, using Data.Array.Accelerate.CUDA it may be on-the-fly off-loaded to the GPU.

Available backends

Currently, there are two backends:

  1. An interpreter that serves as a reference implementation of the intended semantics of the language, which is included in this package.

  2. A CUDA backend generating code for CUDA-capable NVIDIA GPUs: http://hackage.haskell.org/package/accelerate-cuda

Several experimental and/or incomplete backends also exist. If you are interested in helping finish these, please contact us.

  1. Cilk/ICC and OpenCL: https://github.com/AccelerateHS/accelerate-backend-kit

  2. Another OpenCL backend: https://github.com/HIPERFIT/accelerate-opencl

  3. A backend to the Repa array library: https://github.com/blambo/accelerate-repa

Additional components

The following support packages are available:

  1. accelerate-cuda: A high-performance parallel backend targeting CUDA-enabled NVIDIA GPUs. Requires the NVIDIA CUDA SDK and, for full functionality, hardware with compute capability 1.2 or greater. See the table on Wikipedia for supported GPUs: http://en.wikipedia.org/wiki/CUDA#Supported_GPUs

  2. accelerate-examples: Computational kernels and applications showcasing Accelerate, as well as performance and regression tests.

  3. accelerate-io: Fast conversion between Accelerate arrays and other formats, including Repa arrays.

  4. accelerate-fft: Computation of Discrete Fourier Transforms.

Install them from Hackage with cabal install PACKAGE

Examples and documentation

Haddock documentation is included in the package, and a tutorial is available on the GitHub wiki: https://github.com/AccelerateHS/accelerate/wiki

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

  • An implementation of the Canny edge detection algorithm

  • An interactive Mandelbrot set generator

  • A particle-based simulation of stable fluid flows

  • An n-body simulation of gravitational attraction between solid particles

  • A cellular automata simulation

  • A "password recovery" tool, for dictionary lookup of MD5 hashes

Mailing list and contacts
Release notes
  • 0.13.0.0: New array fusion optimisation. New foreign function interface for array and scalar expressions. Additional Prelude-like functions. New example programs. Bug fixes and performance improvements.

  • 0.12.0.0: Full sharing recovery in scalar expressions and array computations. Two new example applications in package accelerate-examples: Real-time Canny edge detection and fluid flow simulator (both including a graphical frontend). Bug fixes.

  • 0.11.0.0: New Prelude-like functions zip*, unzip*, fill, enumFrom*, tail, init, drop, take, slit, gather*, scatter*, and shapeSize. New simplified AST (in package accelerate-backend-kit) for backend writers who want to avoid the complexities of the type-safe AST.

  • 0.10.0.0: Complete sharing recovery for scalar expressions (but currently disabled by default). Also bug fixes in array sharing recovery and a few new convenience functions.

  • 0.9.0.0: Streaming, precompilation, Repa-style indices, stencils, more scans, rank-polymorphic fold, generate, block I/O & many bug fixes.

  • 0.8.1.0: Bug fixes and some performance tweaks.

  • 0.8.0.0: replicate, slice and foldSeg supported in the CUDA backend; frontend and interpreter support for stencil. Bug fixes.

  • 0.7.1.0: The CUDA backend and a number of scalar functions.

Modules

[Index]

  • Data
    • Array
      • Data.Array.Accelerate
        • Data.Array.Accelerate.AST
        • Analysis
          • Data.Array.Accelerate.Analysis.Match
          • Data.Array.Accelerate.Analysis.Shape
          • Data.Array.Accelerate.Analysis.Stencil
          • Data.Array.Accelerate.Analysis.Type
        • Array
          • Data.Array.Accelerate.Array.Data
          • Data.Array.Accelerate.Array.Representation
          • Data.Array.Accelerate.Array.Sugar
        • Data.Array.Accelerate.Debug
        • Data.Array.Accelerate.Interpreter
        • Data.Array.Accelerate.Pretty
        • Data.Array.Accelerate.Smart
        • Data.Array.Accelerate.Trafo
          • Data.Array.Accelerate.Trafo.Sharing
        • Data.Array.Accelerate.Tuple
        • Data.Array.Accelerate.Type

Flags

Automatic Flags
NameDescriptionDefault
debug

Enable tracing message flags. These are read from the command-line arguments, which is convenient but may cause problems interacting with the user program, so are disabled by default. The available options are:

  • -ddump-sharing: print sharing recovery information

  • -ddump-simpl-stats: dump statistics counts from the simplifier phase

  • -ddump-simpl-iterations: dump the program after each iteration of the simplifier

  • -dverbose: other, uncategorised messages

Enabled
more-pp

Enable HTML and Graphviz pretty printing.

Disabled
bounds-checks

Enable bounds checking

Enabled
unsafe-checks

Enable bounds checking in unsafe operations

Disabled
internal-checks

Enable internal consistency checks

Disabled

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

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

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
Dependencies array (>=0.3 && <0.5), base (>=4 && <5), blaze-html (>=0.5 && <0.7), blaze-markup (>=0.5 && <0.6), bytestring (>=0.9 && <0.11), containers (>=0.3 && <0.6), directory (>=1.0 && <1.3), fclabels (>=1.0 && <1.2), filepath (>=1.0 && <1.4), ghc-prim, hashable (>=1.1 && <1.3), hashtables (>=1.0 && <1.2), mtl (>=2.0 && <2.2), pretty (>=1.0 && <1.2), text (>=0.10 && <0.12), unix (>=2.4 && <2.7) [details]
License BSD-3-Clause
Author Manuel M T Chakravarty, Robert Clifton-Everest, Gabriele Keller, Sean Lee, Ben Lever, Trevor L. McDonell, Ryan Newtown, Sean Seefried
Maintainer Manuel M T Chakravarty <chak@cse.unsw.edu.au>
Category 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 git://github.com/AccelerateHS/accelerate.git
Uploaded by TrevorMcDonell at 2013-06-09T12:42:25Z
Distributions
Reverse Dependencies 44 direct, 10 indirect [details]
Downloads 31771 total (56 in the last 30 days)
Rating 2.5 (votes: 6) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]