This monad is used to implement the body of a multi-pass algorithm.

This monad is used to implement the prologue of a multi-pass algorithm.

This monad is used to implement the epilogue of a multi-pass algorithm.

MultiPassMain is an abstract datatype containing the prologue, body, and epilogue of a multi-pass algorithm. Use mkMultiPassMain to construct an object of type MultiPassMain.

Combine the prologue, body, and epilogue of a multi-pass algorithm to create the MultiPassMain object which is required by the run function.

This datatype is used in conjunction with PassZ to package the main function of the multi-pass algorithm. For an example of how they are used, see the implementation of repminMP or any of the other examples in the Example directory.

Used in conjunction with PassS to build a Peano number corresponding to the number of passes.

The main function of a multi-pass algorithm needs to be wrapped in a newtype so that it can be packaged with PassS and PassZ. The newtype needs to be made an instance of MultiPassAlgorithm so that it can unwrapped by the implementation.

This function is used to run a multi-pass algorithm. Its complicated type is mostly an artifact of the internal implementation, which uses type classes to generate the code for each pass of the algorithm. Therefore, the recommended way to learn how to use run is to look at some of the examples in the Example sub-directory.

NumThreads is used to specify the number of threads in parallelMP and parallelMP_.

Use m threads to run n instances of the function f. The results are returned in an array of length n.

Modified version of parallelMP which discards the result of the function, rather than writing it to an array.

Read-only ST2 computations are allowed to be executed in the MultiPass monad.

Trivial monad, equivalent to Identity. Used to switch on a pass of a multi-pass algorithm.

Trivial monad which computes absolutely nothing. It is used to switch off a pass of a multi-pass algorithm.

MultiPass, MultiPassPrologue, and MultiPassEpilogue are trivial newtype wrappers around this monad. Instruments can construct computations in the MultiPassBase monad, but then use mkMultiPass, mkMultiPassPrologue, and mkMultiPassEpilogue to restrict which of the three stages it is allowed to be used in.

Restrict a computation so that it can only be executed during the body of the algorithm (not the prologue or epilogue).

Restrict a computation so that it can only be executed during the prologue.

Restrict a computation so that it can only be executed during the epilogue.

This abstract datatype is used as the result type of createInstrument. Instrument authors can create it using the wrapInstrument function, but cannot unwrap it. This ensures that instruments can only be constructed by the Control.Monad.MultiPass library.

Create an object of type WrapInstrument. It is needed when defining a new instance of the Instrument class.

This datatype is used by the back-tracking mechanism. Instruments can request that the evaluator back-tracks to a specific pass number. Instruments which use back-tracking store the relevant PassNumbers in their global context. The current PassNumber is the first argument of nextGlobalContext for this purpose. PassNumber is an abstract datatype. Instruments should never need to create a new PassNumber or modify an existing one, so no functions that operate on PassNumber are exported from this module.

This datatype is used by the NextThreadContext and NextGlobalContext classes to specify whether the algorithm is progressing to the next pass or back-tracking to a previous pass. When back-tracking occurs, the current thread and global contexts are first passed the StepReset command. Then they are passed the StepBackward command N times, where N is the number of passes that need to be revisited. Note that N can be zero if only the current pass needs to be revisited, so the StepBackward command may not be used. This is the reason why the StepReset command is always issued first.

The type of the first argument of createInstrument. It enables instruments to run ST2 in the MultiPassBase monad. (Clearly the st2ToMP argument needs to be used with care.)

The type of the first argument of createInstrument. It used to read and write the thread context.

Every instrument must define an instance of this class for each of its passes. For example, the Counter instrument defines the following instances:

 instance Instrument tc () () () (Counter i r w Off Off tc) instance Num i => Instrument tc (CounterTC1 i r) () (Counter i r w On Off tc) instance Num i => Instrument tc (CounterTC2 i r) () (Counter i r w On On tc) 

The functional dependency from instr to tc and gc enables the run function to automatically deduce the type of the thread context and global context for each pass.

This class is used when multiple threads are spawned. splitThreadContext is used to create a new thread context for each of the new threads and mergeThreadContext is used to merge them back together when the parallel region ends.

This class is used to create the next thread context when the multi-pass algorithm proceeds to the next pass or back-tracks to the previous pass.

This class is used to create the next global context when the multi-pass algorithm proceeds to the next pass or back-tracks to the previous pass.

Every instrument must define an instance of this class for each of its passes. It is used to tell the evaluator whether it needs to back-track. Instruments which do not back-track should use the default implementation of backtrack which returns Nothing (which means that no back-tracking is necessary.) If more than one instrument requests that the evaluator back-tracks then the evaluator will back-track to the earliest of the requested passes.