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 runtime 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.
Steps are arbitrary Haskell functions (which may themselves expose
Edges in the graph are control and data relationships,
implemented by tag and item collections respectively.
A brief introduction to CnC using this module can be found at http://software.intel.com/en-us/blogs/2010/05/27/announcing-intel-concurrent-collections-for-haskell-01/. General documentation on the CnC model can be found at http://software.intel.com/en-us/articles/intel-concurrent-collections-for-cc/.
- 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
- itemsToList :: (Eq tag, Ord tag, Show tag) => ItemCol tag b -> StepCode [(tag, b)]
- stepPutStr :: String -> StepCode ()
- cncPutStr :: String -> GraphCode ()
- cncVariant :: String
- cncFor :: Int -> Int -> (Int -> StepCode ()) -> StepCode ()
- cncFor2D :: (Int, Int) -> (Int, Int) -> (Int -> Int -> StepCode ()) -> StepCode ()
GraphCode monad represents
computations for constructing CnC graphs.
StepCode monad represents computations
running inside individual nodes of CnC graphs (in parallel).
Construct a new item collection.
Attach a computation step to a supply of control tags. This adds a new node in the computation graph.
Put-Tag. Push a control tag out into the computation graph.
Put an item. Subsequently, any steps waiting on the item may subsequently execute.
Get an item. Synchronous read-data operation.
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.
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.
Construct a CnC graph and execute it to completion. Completion
is defined as the
finalize action having completed.
Convert an entire item collection into an association list. In
general, this can only be done from the
finalize step and
requires selecting a runtime scheduler which supports quiescence, that is,
a scheduler that waits for all active steps to complete before executing
(Currently, all schedulers but version 3 support quiescence.)
Print a message within the graph construction code (unsafe side effect).
An informal identifier of the CnC version presently in use (for example, identifying a scheduler implementation).
cncFor start end body" runs
body in parallel over the inclusive range
Frequently, CnC graphs are serial within steps but parallel at the
level of the graph. In contrast,
cncFor exposes parallelism
within a step. Whether the body of the parallel for is doing
work, or just spawning work via
cncFor can help
distribute the work more efficiently.
A two dimensional loop.
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 <-
getitems "left" word2 <-
putitems "result" (word1 ++ word2 ++ show tag) cncGraph = do tags <-
prescribetags (myStep items)
putitems "left" "hello "
putitems "right" "world "
getitems "result" main = putStrLn (runGraph cncGraph)