Modulescheduler-2.0.1.0Haskell2010

Control.Scheduler.Internal

16 values

Packagescheduler-2.0.1.0
Exports16
LanguageHaskell2010
LicenceBSD-3-Clause
SourceInternal.hs

valuewithSchedulerInternal

:: Comp
Computation strategy
-> (Jobs IO a -> (WorkerId -> IO a) -> IO ())
How to schedule work
-> (JQueue IO a -> IO [a])
How to collect results
-> (Scheduler RealWorld a -> IO b)
Action that will be scheduling all the work.
-> IO (Results a)

valueinitWorkerStates

:: MonadIO m
=> Comp
-> WorkerId -> m ws
-> m (WorkerStates ws)

Initialize a separate state for each worker.

valuewithSchedulerWSInternal

:: MonadUnliftIO m
=> Comp -> (Scheduler RealWorld a -> t) -> m b
-> WorkerStates ws
-> SchedulerWS ws a -> t
-> m b

valuetrivialScheduler_ :: Scheduler s ()

The most basic scheduler that simply runs the task instead of scheduling it. Early termination requests are bluntly ignored.

valuewithTrivialSchedulerR

:: (PrimMonad m, s ~ PrimState m)
=> Scheduler s a -> m b
-> m (Results a)

This trivial scheduler will behave in a similar way as withSchedulerR with Seq computation strategy, except it is restricted to PrimMonad, instead of MonadUnliftIO and the work isn't scheduled, but rather computed immediately.

valuewithTrivialSchedulerRIO

:: MonadUnliftIO m
=> Scheduler RealWorld a -> m b
-> m (Results a)

Same as withTrivialScheduler, but works in MonadUnliftIO and returns results in an original LIFO order.

valueinitScheduler

:: Comp
-> Jobs IO a -> (WorkerId -> IO a) -> IO ()
-> JQueue IO a -> IO [a]
-> IO (Jobs IO a, [ThreadId] -> Scheduler RealWorld a)

valuespawnWorkers :: MonadUnliftIO m => Jobs m a -> Comp -> m [ThreadId]

valueterminateWorkers :: [ThreadId] -> IO ()

valuescheduleJobs :: MonadIO m => Jobs m a -> (WorkerId -> m a) -> m ()

valuescheduleJobs_ :: MonadIO m => Jobs m a -> (WorkerId -> m b) -> m ()

Ignores the result of computation, thus avoiding some overhead.

valuescheduleJobsWith

:: MonadIO m
=> ((b -> m ()) -> WorkerId -> m ()) -> m (Job m a)
-> Jobs m a
-> WorkerId -> m b
-> m ()

valuereverseResults :: Results a -> Results a

valueresultsToList :: Results a -> [a]

Conversion to a list. Elements are expected to be in the orignal LIFO order, so calling reverse is still necessary for getting the results in FIFO order.

valuetraverse_ :: (Applicative f, Foldable t) => (a -> f ()) -> t a -> f ()

This is generally a faster way to traverse while ignoring the result rather than using mapM_.

valuesafeBracketOnError

:: MonadUnliftIO m
=> m a
-> a -> m b
-> a -> m c
-> m c