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