# 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, using
`Data.Array.Accelerate.CUDA`

it may be on-the-fly off-loaded to the GPU.

*Available backends*

Currently, there are two backends:

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

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.

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

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

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

*Additional components*

The following support packages are available:

`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`accelerate-examples`

: Computational kernels and applications showcasing*Accelerate*, as well as performance and regression tests.`accelerate-io`

: Fast conversion between*Accelerate*arrays and other formats, including Repa arrays.`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 particlesA cellular automata simulation

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

*Mailing list and contacts*

Mailing list: accelerate-haskell@googlegroups.com (discussion of both use and development welcome).

Sign up for the mailing list here: http://groups.google.com/group/accelerate-haskell

Bug reports and issue tracking: https://github.com/AccelerateHS/accelerate/issues

*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,`stencil`

s, more`scan`

s, 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.

Versions | 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 |
---|---|

Dependencies | array (>=0.3 && <0.5), base (==4.*), blaze-html (>=0.5 && <0.7), blaze-markup (==0.5.*), 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 Sat May 11 08:57:43 UTC 2013 |

Distributions | NixOS:1.2.0.0 |

Downloads | 15688 total (301 in the last 30 days) |

Rating | 2.5 (votes: 3) [estimated by rule of succession] |

Your Rating | |

Status | Docs available [build log] Successful builds reported [all 2 reports] Hackage Matrix CI |

## 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

- Data.Array.Accelerate

## Flags

Name | Description | Default | Type |
---|---|---|---|

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 | Automatic |

more-pp | Enable HTML and Graphviz pretty printing. | Disabled | Automatic |

bounds-checks | Enable bounds checking | Enabled | Automatic |

unsafe-checks | Enable bounds checking in unsafe operations | Disabled | Automatic |

internal-checks | Enable internal consistency checks | Disabled | Automatic |

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

## Downloads

- accelerate-0.13.0.0.tar.gz [browse] (Cabal source package)
- Package description (as included in the package)