ghc-accelerate

'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.
[/Additional components/]
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/]

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

          

---

License: BSD-3-Clause
URL: https://hackage.haskell.org/package/accelerate