Difference between revisions of "GHC/Data Parallel Haskell/Package NDP"

From HaskellWiki
Jump to: navigation, search
(Installation)
(A small example)
Line 47: Line 47:
 
</pre></blockquote>
 
</pre></blockquote>
   
Most of the functions under [http://darcs.haskell.org/packages/ndp/Data/Array/Parallel/Unlifted/ <tt>Data.Array.Parallel.Unlifted</tt>] are still purely sequential, albeit '''much''' more efficient than <tt>GHC.PArr</tt>. In addition, the (currently only few) functions from [http://darcs.haskell.org/packages/ndp/Data/Array/Parallel/Unlifted/Parallel.hs <tt>Data.Array.Parallel.Unlifted.Parallel</tt>] ''transparently'' use multiple processing elements if GHC was compiled with SMP multiprocessor support.
+
Most of the functions under are still purely sequential, albeit '''much''' more efficient than <tt>GHC.PArr</tt>. In addition, the (currently only few) functions from [http://darcs.haskell.org/packages/ndp/Data/Array/Parallel/Unlifted/Parallel.hs <tt>Data.Array.Parallel.Unlifted.Parallel</tt>] ''transparently'' use multiple processing elements if GHC was compiled with SMP multiprocessor support.
  +
  +
=== More examples ===
   
 
A number of examples of using package ndp are in the [http://darcs.haskell.org/packages/ndp/examples/ examples directory;] for details refer to the [http://darcs.haskell.org/packages/ndp/examples/README README] file.
 
A number of examples of using package ndp are in the [http://darcs.haskell.org/packages/ndp/examples/ examples directory;] for details refer to the [http://darcs.haskell.org/packages/ndp/examples/README README] file.
  +
  +
=== Writing NDP programs ===
  +
  +
You need to import [http://darcs.haskell.org/packages/ndp/Data/Array/Parallel/Unlifted/ <tt>Data.Array.Parallel.Unlifted</tt>] (sequential combinators) and/or
  +
[http://darcs.haskell.org/packages/ndp/Data/Array/Parallel/Unlifted/Parallel.hs <tt>Data.Array.Parallel.Unlifted.Parallel</tt>] (parallel combinators). The abovementioned examples should prove useful to get a feel for how these combinators are used.
  +
  +
Before invoking any parallel combinators you must initialise the gang threads,
  +
usually by calling
  +
<blockquote><pre>
  +
Data.Array.Parallel.Unlifted.Distributed.setGang <T>
  +
</pre></blockquote>
  +
where <tt><T></tt> is the number of threads. In addition, you need to pass the command line option <tt>+RTS -N<T></tt> to the executable; otherwise, you won't get any parallelism. This is a regrettable hack which will go away eventually.
  +
  +
=== Compiling NDP programs ===
  +
  +
The file [http://darcs.haskell.org/packages/ndp/ndp.mk ndp.mk] shows the options you'll usually want for compiling NDP
  +
programs. You don't need <tt>-fbang-patterns</tt> unless you actually use them. You might get away with omitting <tt>-fmax-simplifier-iterations6</tt>; however, sometimes GHC will really need that many iterations to fully optimise NDP programs.

Revision as of 07:36, 20 March 2007

Speed with less convenience: package ndp

The following explains how to install and use the concurrent, high-performance library of strict, segmented arrays called package ndp. Here, strict means that when one element of an array is evaluated, all of them are - we also call this a parallel evaluation semantics. Moreover, segmented means that all operations come in two flavours: one for plain, flat arrays and one for segmented arrays, which are an optimised representation of arrays with one level of nesting. For example, a sum of a segmented array of numbers computes one sum for each segment. Package ndp has a purely functional interface, but internally uses monadic low-level array operations, array fusion, and a many standard GHC optimisations to produce highly optimised code. The library uses GHC's SMP concurrency to transparently parallelise array processing on hardware with multiple cores and/or CPUs.

Installation

Package ndp is only available in source form. The simplest way to build it is to first get and build a source distribution of GHC (preferably the current development version) - see the docu on how to get the sources and how to build them. Then, in the source tree, do the following

% cd libraries
% darcs get http://darcs.haskell.org/packages/ndp/
% cd ndp
% make boot
% make
% cd examples
% make

If you don't have darcs, you can alternatively download the ndp-0.1 tar ball. Now, the option -package ndp is available for use with the inplace compiler (i.e., compiler/ghc-inplace). Alternatively, you can install it by invoking make install on the GHC source root and within libraries/ndp/. Then, the option -package ndp can be used in the installed compiler.

A small example

The following module implements the dot product of two vectors with package ndp:

module DotP_ndp (dotp)
where

import Data.Array.Parallel.Unlifted

dotp :: (Num a, UA a) => UArr a -> UArr a -> a
dotp xs ys = sumU (zipWithU (*) xs ys)

We can also use that in an interactive GHCi session:

Prelude> :set -package ndp
package flags have changed, ressetting and loading new packages...
Loading package ndp-1.0 ... linking ... done.
Prelude> :l /home/chak/code/haskell/DotP_ndp
[1 of 1] Compiling DotP_ndp         ( /home/chak/code/haskell/DotP_ndp.hs, interpreted )
Ok, modules loaded: DotP_ndp.
*DotP_ndp> dotp (toU [1..3]) (toU [4..6])
Loading package haskell98 ... linking ... done.
32.0
*DotP_ndp>

Most of the functions under are still purely sequential, albeit much more efficient than GHC.PArr. In addition, the (currently only few) functions from Data.Array.Parallel.Unlifted.Parallel transparently use multiple processing elements if GHC was compiled with SMP multiprocessor support.

More examples

A number of examples of using package ndp are in the examples directory; for details refer to the README file.

Writing NDP programs

You need to import Data.Array.Parallel.Unlifted (sequential combinators) and/or Data.Array.Parallel.Unlifted.Parallel (parallel combinators). The abovementioned examples should prove useful to get a feel for how these combinators are used.

Before invoking any parallel combinators you must initialise the gang threads, usually by calling

Data.Array.Parallel.Unlifted.Distributed.setGang <T>

where <T> is the number of threads. In addition, you need to pass the command line option +RTS -N<T> to the executable; otherwise, you won't get any parallelism. This is a regrettable hack which will go away eventually.

Compiling NDP programs

The file ndp.mk shows the options you'll usually want for compiling NDP programs. You don't need -fbang-patterns unless you actually use them. You might get away with omitting -fmax-simplifier-iterations6; however, sometimes GHC will really need that many iterations to fully optimise NDP programs.