|haskell-cnc-0.1.2: Library for parallel programming in the Intel Concurrent Collections paradigm.||Contents||Index|
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
|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).
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)
do tags <- newTagCol
items <- newItemCol
prescribe tags (mystep items)
do put items "left" "hello "
put items "right" "world "
putt tags 99
do get items "result"
main = putStrLn (runGraph cncGraph)
|Produced by Haddock version 2.6.0|