Test.DejaFu.Conc.Internal

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.

Set-up

type SeqTrace = Seq (Decision, [(ThreadId, Lookahead)], ThreadAction)

Trace but as a sequence.

data CResult n g a

The result of running a concurrent program.

Constructors

CResult

Fields

• finalContext :: Context n g
• finalRef :: IORef n (Maybe (Either Condition a))
• finalRestore :: Threads n -> n ()

  Meaningless if this result doesn't come from a snapshotting execution.

• finalTrace :: SeqTrace
• finalDecision :: Maybe (ThreadId, ThreadAction)

runConcurrency :: (MonadConc n, HasCallStack) => [Invariant n ()] -> Bool -> Scheduler g -> MemType -> g -> IdSource -> Int -> ModelConc n a -> n (CResult n g a)

Run a concurrent computation with a given Scheduler and initial state, returning a Condition reason on error. Also returned is the final state of the scheduler, and an execution trace.

runConcurrencyWithSnapshot :: (MonadConc n, HasCallStack) => Scheduler g -> MemType -> Context n g -> (Threads n -> n ()) -> ModelConc n a -> n (CResult n g a)

Like runConcurrency but starts from a snapshot.

killAllThreads :: (MonadConc n, HasCallStack) => Context n g -> n ()

Kill the remaining threads

Execution

data Context n g

The context a collection of threads are running in.

Constructors

Context

Fields

• cSchedState :: g
• cIdSource :: IdSource
• cThreads :: Threads n
• cWriteBuf :: WriteBuffer n
• cCaps :: Int
• cInvariants :: InvariantContext n
• cNewInvariants :: [Invariant n ()]
• cCState :: ConcurrencyState

runThreads :: (MonadConc n, HasCallStack) => Bool -> Scheduler g -> MemType -> IORef n (Maybe (Either Condition a)) -> Context n g -> n (CResult n g a)

Run a collection of threads, until there are no threads left.

fixContext :: MemType -> ThreadId -> ThreadAction -> What n g -> Context n g -> Context n g

Apply the context update from stepping an action.

unblockWaitingOn :: ThreadId -> Threads n -> Threads n

unblockWaitingOn tid unblocks every thread blocked in a throwTo tid.

Single-step execution

data What n g

What a thread did, for execution purposes.

Constructors

Succeeded (Context n g)

Action succeeded: continue execution.

Failed Condition

Action caused computation to fail: stop.

stepThread

Arguments

:: (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, ThreadAction, 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.

stepThrow

Arguments

:: (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, ThreadAction, Threads n -> n ())

Handle an exception being thrown from an AAtom, AThrow, or AThrowTo.

synchronised

Arguments

:: MonadConc n

=> (Context n g -> n x)

Action to run after the write barrier.

-> Context n g

The original execution context.

-> n x

Helper for actions impose a write barrier.

Invariants

data InvariantContext n

The state of the invariants

Constructors

InvariantContext

Fields

• icActive :: [Invariant n ()]
• icBlocked :: [(Invariant n (), ([IORefId], [MVarId], [TVarId]))]

unblockInvariants :: ThreadAction -> InvariantContext n -> InvariantContext n

unblockInvariants act unblocks every invariant which could have its result changed by act.

checkInvariants :: MonadConc n => InvariantContext n -> n (Either SomeException (InvariantContext n))

Check all active invariants, returning an arbitrary failure if multiple ones fail.

checkInvariant :: MonadConc n => Invariant n a -> n (Either SomeException ([IORefId], [MVarId], [TVarId]))

Check an invariant.

doInvariant :: MonadConc n => Invariant n a -> n (Either SomeException a, [IORefId], [MVarId], [TVarId])

Run an invariant (more primitive)

stepInvariant :: MonadConc n => IAction n -> n (Either SomeException (Maybe (IAction n)), [IORefId], [MVarId], [TVarId])

Run an invariant for one step