Copyright | (c) 2016--2018 Michael Walker |
---|---|
License | MIT |
Maintainer | Michael Walker <mike@barrucadu.co.uk> |
Stability | experimental |
Portability | FlexibleContexts, MultiWayIf, RankNTypes, RecordWildCards |
Safe Haskell | None |
Language | Haskell2010 |
Concurrent monads with a fixed scheduler: internal types and functions. This module is NOT considered to form part of the public interface of this library.
Synopsis
- type SeqTrace = Seq (Decision, [(ThreadId, Lookahead)], ThreadAction)
- data CResult n g a = CResult {
- finalContext :: Context n g
- finalRef :: IORef n (Maybe (Either Failure a))
- finalRestore :: Maybe (Threads n -> n ())
- finalTrace :: SeqTrace
- finalDecision :: Maybe (ThreadId, ThreadAction)
- data DCSnapshot n a = DCSnapshot {
- dcsContext :: Context n ()
- dcsRestore :: Threads n -> n ()
- dcsRef :: IORef n (Maybe (Either Failure a))
- runConcurrency :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> g -> IdSource -> Int -> ModelConc n a -> n (CResult n g a)
- runConcurrency' :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> Context n g -> ModelConc n a -> n (CResult n g a)
- runConcurrencyWithSnapshot :: (MonadConc n, HasCallStack) => Scheduler g -> MemType -> Context n g -> (Threads n -> n ()) -> IORef n (Maybe (Either Failure a)) -> n (CResult n g a)
- killAllThreads :: (MonadConc n, HasCallStack) => Context n g -> n ()
- data Context n g = Context {
- cSchedState :: g
- cIdSource :: IdSource
- cThreads :: Threads n
- cWriteBuf :: WriteBuffer n
- cCaps :: Int
- runThreads :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> IORef n (Maybe (Either Failure a)) -> Context n g -> n (CResult n g a)
- fixContext :: ThreadId -> What n g -> Context n g -> Context n g
- unblockWaitingOn :: ThreadId -> Threads n -> Threads n
- data Act
- = Single ThreadAction
- | SubC SeqTrace (Maybe (ThreadId, ThreadAction))
- data What n g
- stepThread :: (MonadConc n, HasCallStack) => Bool -> Bool -> Scheduler g -> MemType -> ThreadId -> Action n -> Context n g -> n (What n g, Act, Threads n -> n ())
- stepThrow :: (MonadConc n, Exception e) => (Bool -> ThreadAction) -> ThreadId -> e -> Context n g -> n (What n g, Act, Threads n -> n ())
- synchronised :: MonadConc n => (Context n g -> n (What n g, Act, Threads n -> n ())) -> Context n g -> n (What n g, Act, Threads n -> n ())
- dcSched :: Scheduler (Maybe Int)
Set-up
type SeqTrace = Seq (Decision, [(ThreadId, Lookahead)], ThreadAction) Source #
Trace
but as a sequence.
The result of running a concurrent program.
CResult | |
|
data DCSnapshot n a Source #
A snapshot of the concurrency state immediately after dontCheck
finishes.
Since: dejafu-1.4.0.0
DCSnapshot | |
|
runConcurrency :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> g -> IdSource -> Int -> ModelConc n a -> n (CResult n g a) Source #
Run a concurrent computation with a given Scheduler
and initial
state, returning a failure reason on error. Also returned is the
final state of the scheduler, and an execution trace.
runConcurrency' :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> Context n g -> ModelConc n a -> n (CResult n g a) Source #
Run a concurrent program using the given context, and without killing threads which remain at the end. The context must have no main thread.
Only a separate function because ADontCheck
needs it.
runConcurrencyWithSnapshot :: (MonadConc n, HasCallStack) => Scheduler g -> MemType -> Context n g -> (Threads n -> n ()) -> IORef n (Maybe (Either Failure a)) -> n (CResult n g a) Source #
Like runConcurrency
but starts from a snapshot.
killAllThreads :: (MonadConc n, HasCallStack) => Context n g -> n () Source #
Kill the remaining threads
Execution
The context a collection of threads are running in.
Context | |
|
runThreads :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> IORef n (Maybe (Either Failure a)) -> Context n g -> n (CResult n g a) Source #
Run a collection of threads, until there are no threads left.
fixContext :: ThreadId -> What n g -> Context n g -> Context n g Source #
Apply the context update from stepping an action.
unblockWaitingOn :: ThreadId -> Threads n -> Threads n Source #
unblockWaitingOn tid
unblocks every thread blocked in a
throwTo tid
.
Single-step execution
What a thread did, for trace purposes.
Single ThreadAction | Just one action. |
SubC SeqTrace (Maybe (ThreadId, ThreadAction)) |
|
What a thread did, for execution purposes.
:: (MonadConc n, HasCallStack) | |
=> Bool | Should we record a snapshot? |
-> Bool | Is this the first action? |
-> Scheduler g | The scheduler. |
-> MemType | The memory model to use. |
-> ThreadId | ID of the current thread |
-> Action n | Action to step |
-> Context n g | The execution context. |
-> n (What n g, Act, Threads n -> n ()) |
Run a single thread one step, by dispatching on the type of
Action
.
Each case looks very similar. This is deliberate, so that the essential differences between actions are more apparent, and not hidden by accidental differences in how things are expressed.
Note: the returned snapshot action will definitely not do the right thing with relaxed memory.
:: (MonadConc n, Exception e) | |
=> (Bool -> ThreadAction) | Action to include in the trace. |
-> ThreadId | The thread receiving the exception. |
-> e | Exception to raise. |
-> Context n g | The execution context. |
-> n (What n g, Act, Threads n -> n ()) |
Handle an exception being thrown from an AAtom
, AThrow
, or
AThrowTo
.