| Portability | POSIX |
|---|---|
| Stability | experimental |
| Maintainer | bastianholst@gmx.de |
| Safe Haskell | Safe-Inferred |
Control.Concurrent.Bag.SafeConcurrent
Description
High level bag of tasks interface based on Control.Concurrent.Concurrent.
Tasks can only return results and add new tasks as intended and it is not
possible to add new tasks from the outside or from the action processing the
results. This way it is possible to ensure that getResults returns only
Nothing if it is safe to say that there will be no results anymore.
- data BagT r m a
- newTaskBag :: MonadIO m => BufferType -> [TaskIO r (Maybe r)] -> BagT r m a -> m a
- newEvalBag :: MonadIO m => BufferType -> [r] -> BagT r m a -> m a
- newInterruptibleBag :: MonadIO m => BufferType -> [Interruptible r] -> BagT r m a -> m a
- newInterruptingBag :: MonadIO m => BufferType -> [Interruptible r] -> BagT r m a -> m a
- getResult :: MonadIO m => BagT r m (Maybe r)
- getAllResults :: MonadIO m => BagT a m [a]
- liftIO :: MonadIO m => forall a. IO a -> m a
- lift :: MonadTrans t => forall m a. Monad m => m a -> t m a
- module Control.Concurrent.Bag.Task
- data BufferType
Documentation
A monad transformer for processing the results of the bag sequencially.
In addition to the actions available in the base monad, which has to be
an instance of MonadIO in all functions, it provides the action
getResult to get a result of the bag.
Arguments
| :: MonadIO m | |
| => BufferType | buffer type |
| -> [TaskIO r (Maybe r)] | list of initial tasks |
| -> BagT r m a | action to process the results of the bag |
| -> m a |
Initializes a new bag of tasks and starts a gang of workers threads. The
number of worker threads is equal to the number of capabilities of the
Haskell runtime (see getNumCapabilities).
__WARNING__: If it may be necessary to terminate the thread pool, i.e.
because the result processing function does not always request all values,
you have to make sure that the task can be stopped.
Terminating the tasks is done with asynchronous exceptions which can only be
received at a emph{safe point}. Safe points are all points where memory
allocation is requested, but there are calculations and also loops which never
need any new memory. These calculations cannot be terminated and may run
forever, see the documentation of throwTo.
Arguments
| :: MonadIO m | |
| => BufferType | buffer type |
| -> [r] | expressions to evaluate |
| -> BagT r m a | action to process the results of the bag |
| -> m a |
Like newTaskBag, but it takes a list of expressions that will be
evaluated to weak head normal form using seq.
__WARNING__: This does not evaluate to normal form, but only to weak head normal form.
Arguments
| :: MonadIO m | |
| => BufferType | buffer type |
| -> [Interruptible r] | list of initial tasks |
| -> BagT r m a | action to process the results of the bag |
| -> m a |
Similar to newTaskBag, but taking a list of Interruptible instead of
tasks.
Arguments
| :: MonadIO m | |
| => BufferType | buffer type |
| -> [Interruptible r] | list of initial tasks |
| -> BagT r m a | action to process the results of the bag |
| -> m a |
Similar to newInterruptibleBag, but interrupts the tasks in certain intervals.
Using a TChan as buffer, this ensures
completeness: all tasks that have a result will get their time to evaluate
it. Note, that calculations, that do no memory allocation, cannot be
interrupted.
getResult :: MonadIO m => BagT r m (Maybe r)Source
Get a result of the bag if there is one. If it returns Nothing, all tasks
have been processed and there are no results left. getResults blocks
until a task has been evaluated to a result or all tasks are processed.
Therefore it may block forever.
getAllResults :: MonadIO m => BagT a m [a]Source
Convenience function to get all results from the bag of tasks.
lift :: MonadTrans t => forall m a. Monad m => m a -> t m a
Lift a computation from the argument monad to the constructed monad.
module Control.Concurrent.Bag.Task