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.

Execution

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

Trace but as a sequence.

data CResult n r g a

The result of running a concurrent program.

Constructors

CResult

Fields

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

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

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

data DCSnapshot r n a

A snapshot of the concurrency state immediately after dontCheck finishes.

Since: 1.1.0.0

Constructors

DCSnapshot

Fields

• dcsContext :: Context n r ()

  The execution context. The scheduler state is ignored when restoring.

• dcsRestore :: Threads n r -> n ()

  Action to restore CRef, MVar, and TVar values.

• dcsRef :: r (Maybe (Either Failure a))

  Reference where the result will be written.

runConcurrency :: (MonadConc n, MonadRef r n) => Bool -> Scheduler g -> MemType -> g -> IdSource -> Int -> M n r a -> n (CResult n r g a)

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.

runConcurrencyWithSnapshot :: (MonadConc n, MonadRef r n) => Scheduler g -> MemType -> Context n r g -> (Threads n r -> n ()) -> r (Maybe (Either Failure a)) -> n (CResult n r g a)

Like runConcurrency but starts from a snapshot.

killAllThreads :: MonadConc n => Context n r g -> n ()

Kill the remaining threads

runConcurrency' :: (MonadConc n, MonadRef r n) => Bool -> Scheduler g -> MemType -> Context n r g -> M n r a -> n (CResult n r g a)

Run a concurrent program using the given context, and without killing threads which remain at the end. The context must have no main thread.

runConcurrency'' :: (MonadConc n, MonadRef r n) => Bool -> Scheduler g -> MemType -> r (Maybe (Either Failure a)) -> Context n r g -> n (CResult n r g a)

Like runConcurrency' but doesn't do *ANY* set up at all.

data Context n r g

The context a collection of threads are running in.

Constructors

Context

Fields

• cSchedState :: g
• cIdSource :: IdSource
• cThreads :: Threads n r
• cWriteBuf :: WriteBuffer r
• cCaps :: Int

runThreads :: (MonadConc n, MonadRef r n) => Bool -> Scheduler g -> MemType -> r (Maybe (Either Failure a)) -> Context n r g -> n (Context n r g, SeqTrace, Maybe (ThreadId, ThreadAction), Maybe (Threads n r -> n ()))

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

Single-step execution

data Act

What a thread did, for trace purposes.

Constructors

Single ThreadAction

Just one action.

SubC SeqTrace (Maybe (ThreadId, ThreadAction))

subconcurrency, with the given trace and final action.

Instances

Eq Act

Methods

(==) :: Act -> Act -> Bool

(/=) :: Act -> Act -> Bool

Show Act

Methods

showsPrec :: Int -> Act -> ShowS

show :: Act -> String

showList :: [Act] -> ShowS

data What n r g

What a thread did, for execution purposes.

Constructors

Succeeded (Context n r g)

Action succeeded: continue execution.

Failed Failure

Action caused computation to fail: stop.

Snap (Context n r g)

Action was a snapshot point and we're in snapshot mode: stop.

stepThread

Arguments

:: (MonadConc n, MonadRef r n)

=> 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 r

Action to step

-> Context n r g

The execution context.

-> n (What n r g, Act, Threads n r -> n ())

Run a single thread one step, by dispatching on the type of Action.

Note: the returned snapshot action will definitely not do the right thing with relaxed memory.