haskell-cnc-0.1.2: Library for parallel programming in the Intel Concurrent Collections paradigm.ContentsIndex
Intel.Cnc
Contents
Example Program
Description

This module implements the Intel Concurrent Collections (CnC) programming model. The variations of this module (Intel.Cnc3, Intel.Cnc5, Intel.Cnc6, and Intel.Cnc8) each implement the same programming model using different schedulers. All of them internally use the IO monad but expose a pure interface. (The module Intel.CncPure is an alternative implementation that exposes the same interface as this module but is internally pure.)

CnC is a data-flow like deterministic parallel programming model. To use it, one constructs a CnC graph of computation steps. Edges in the graph are control and data relationships, which are implemented by tag and item collections respectively.

A brief introduction to CnC using this module can be found at http://software.intel.com/foobar. General documentation on the CnC model can be found at http://software.intel.com/en-us/articles/intel-concurrent-collections-for-cc/.

Synopsis
type Step a = a -> StepCode ()
newItemCol :: (Eq tag, Ord tag, Show tag) => GraphCode (ItemCol tag val)
newTagCol :: GraphCode (TagCol tag)
prescribe :: TagCol tag -> Step tag -> GraphCode ()
putt :: TagCol tag -> tag -> StepCode ()
put :: (Eq tag, Ord tag, Show tag) => ItemCol tag val -> tag -> val -> StepCode ()
get :: (Eq tag, Ord tag, Show tag) => ItemCol tag val -> tag -> StepCode val
initialize :: StepCode a -> GraphCode a
finalize :: StepCode a -> GraphCode a
runGraph :: GraphCode a -> a
stepPutStr :: String -> StepCode ()
cncPutStr :: String -> GraphCode ()
cncVariant :: String
Documentation
type Step a = a -> StepCode ()
Steps are functions that take a single tag as input and perform a computation in the StepCode monad, which may perform puts and gets.
The GraphCode monad represents computations for constructing CnC graphs.
The StepCode monad represents computations running inside individual nodes of CnC graphs (in parallel).
newItemCol :: (Eq tag, Ord tag, Show tag) => GraphCode (ItemCol tag val)
Construct a new item collection.
newTagCol :: GraphCode (TagCol tag)
Construct a new tag collection.
prescribe :: TagCol tag -> Step tag -> GraphCode ()
Attach a computation step to a supply of control tags. This adds a new node in the computation graph.
putt :: TagCol tag -> tag -> StepCode ()
Put-Tag. Push a control tag out into the computation graph.
put :: (Eq tag, Ord tag, Show tag) => ItemCol tag val -> tag -> val -> StepCode ()
Put an item. Subsequently, any steps waiting on the item may subsequently execute.
get :: (Eq tag, Ord tag, Show tag) => ItemCol tag val -> tag -> StepCode val
Get an item. Synchronous read-data operation.
initialize :: StepCode a -> GraphCode a
Run an initial step which populates the CnC graph with input tags and items. Presently only a single initialize is allowed within a graph execution.
finalize :: StepCode a -> GraphCode a
Run a final step which collects outputs of the graph that are of interest to the larger application. Presently only a single finalize is allowed within a graph execution.
runGraph :: GraphCode a -> a
Construct a CnC graph and execute it to completion. Completion is defined as the finalize action having completed.
stepPutStr :: String -> StepCode ()
Print a message within a step (unsafe side effect).
cncPutStr :: String -> GraphCode ()
Print a message within the graph construction code (unsafe side effect).
cncVariant :: String
An informal identifier of the CnC version presently in use (for example, identifying a scheduler implementation).
Example Program

Below is a simple program that prints "Hello World 99". Item collections are indexed by string tags (keys). The CnC graph consists of one node. 

myStep items tag =
  do word1 <- get items "left"
     word2 <- get items "right"
     put items "result" (word1 ++ word2 ++ show tag)

cncGraph = 
  do tags  <- newTagCol
     items <- newItemCol
     prescribe tags (mystep items)
     initialize $
        do put items "left"  "hello "
           put items "right" "world "
           putt tags 99
     finalize $ 
        do get items "result"

main = putStrLn (runGraph cncGraph)
Produced by Haddock version 2.6.0