accelerate-1.0.0.0: An embedded language for accelerated array processing

# accelerate-1.0.0.0: 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.LLVM.PTX it may be on-the-fly off-loaded to the GPU.

The following supported add-ons are available as separate packages. Install them from Hackage with cabal install <package>

• accelerate-llvm-native: Backend supporting parallel execution on multicore CPUs.
• accelerate-llvm-ptx: Backend supporting parallel execution on CUDA-capable NVIDIA GPUs. Requires a GPU with compute capability 2.0 or greater. See the following table for supported GPUs: http://en.wikipedia.org/wiki/CUDA#Supported_GPUs
• accelerate-cuda: Backend targeting CUDA-enabled NVIDIA GPUs. Requires a GPU with compute compatibility 1.2 or greater. /NOTE: This backend is being deprecated in favour of accelerate-llvm-ptx./
• 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 conversions between Accelerate arrays and other array formats (including vector and repa).
• accelerate-fft: Discrete Fourier transforms, with FFI bindings to optimised implementations.
• accelerate-bignum: Fixed-width large integer arithmetic.
• colour-accelerate: Colour representations in Accelerate (RGB, sRGB, HSV, and HSL).
• gloss-accelerate: Generate gloss pictures from Accelerate.
• gloss-raster-accelerate: Parallel rendering of raster images and animations.
• lens-accelerate: Lens operators for Accelerate types.
• linear-accelerate: Linear vector spaces in Accelerate.
• mwc-random-accelerate: Generate Accelerate arrays filled with high quality pseudorandom numbers.
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:

• 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
• An implementation of the PageRank algorithm
• A simple interactive ray tracer
• A particle based simulation of stable fluid flows
• A cellular automata simulation
• A "password recovery" tool, for dictionary lookup of MD5 hashes

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