type STM (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type STM (IOSim s)
type TVar (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TVar (IOSim s)
type TMVar (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TMVar (IOSim s) = TMVarDefault (IOSim s)
type TQueue (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TQueue (IOSim s)
type TBQueue (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TBQueue (IOSim s)
type TArray (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TArray (IOSim s) = TArrayDefault (IOSim s)
type TSem (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TSem (IOSim s) = TSemDefault (IOSim s)
type TChan (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type TChan (IOSim s) = TChanDefault (IOSim s)

Methods

atomically :: HasCallStack => STM (IOSim s) a -> IOSim s a

newTVar :: a -> STM (IOSim s) (TVar (IOSim s) a)

readTVar :: TVar (IOSim s) a -> STM (IOSim s) a

writeTVar :: TVar (IOSim s) a -> a -> STM (IOSim s) ()

retry :: STM (IOSim s) a

orElse :: STM (IOSim s) a -> STM (IOSim s) a -> STM (IOSim s) a

modifyTVar :: TVar (IOSim s) a -> (a -> a) -> STM (IOSim s) ()

modifyTVar' :: TVar (IOSim s) a -> (a -> a) -> STM (IOSim s) ()

stateTVar :: TVar (IOSim s) s0 -> (s0 -> (a, s0)) -> STM (IOSim s) a

swapTVar :: TVar (IOSim s) a -> a -> STM (IOSim s) a

check :: Bool -> STM (IOSim s) ()

newTMVar :: a -> STM (IOSim s) (TMVar (IOSim s) a)

newEmptyTMVar :: STM (IOSim s) (TMVar (IOSim s) a)

takeTMVar :: TMVar (IOSim s) a -> STM (IOSim s) a

tryTakeTMVar :: TMVar (IOSim s) a -> STM (IOSim s) (Maybe a)

putTMVar :: TMVar (IOSim s) a -> a -> STM (IOSim s) ()

tryPutTMVar :: TMVar (IOSim s) a -> a -> STM (IOSim s) Bool

readTMVar :: TMVar (IOSim s) a -> STM (IOSim s) a

tryReadTMVar :: TMVar (IOSim s) a -> STM (IOSim s) (Maybe a)

swapTMVar :: TMVar (IOSim s) a -> a -> STM (IOSim s) a

writeTMVar :: TMVar (IOSim s) a -> a -> STM (IOSim s) ()

isEmptyTMVar :: TMVar (IOSim s) a -> STM (IOSim s) Bool

newTQueue :: STM (IOSim s) (TQueue (IOSim s) a)

readTQueue :: TQueue (IOSim s) a -> STM (IOSim s) a

tryReadTQueue :: TQueue (IOSim s) a -> STM (IOSim s) (Maybe a)

peekTQueue :: TQueue (IOSim s) a -> STM (IOSim s) a

tryPeekTQueue :: TQueue (IOSim s) a -> STM (IOSim s) (Maybe a)

flushTQueue :: TQueue (IOSim s) a -> STM (IOSim s) [a]

writeTQueue :: TQueue (IOSim s) a -> a -> STM (IOSim s) ()

isEmptyTQueue :: TQueue (IOSim s) a -> STM (IOSim s) Bool

unGetTQueue :: TQueue (IOSim s) a -> a -> STM (IOSim s) ()

newTBQueue :: Natural -> STM (IOSim s) (TBQueue (IOSim s) a)

readTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) a

tryReadTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) (Maybe a)

peekTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) a

tryPeekTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) (Maybe a)

flushTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) [a]

writeTBQueue :: TBQueue (IOSim s) a -> a -> STM (IOSim s) ()

lengthTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) Natural

isEmptyTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) Bool

isFullTBQueue :: TBQueue (IOSim s) a -> STM (IOSim s) Bool

unGetTBQueue :: TBQueue (IOSim s) a -> a -> STM (IOSim s) ()

newTSem :: Integer -> STM (IOSim s) (TSem (IOSim s))

waitTSem :: TSem (IOSim s) -> STM (IOSim s) ()

signalTSem :: TSem (IOSim s) -> STM (IOSim s) ()

signalTSemN :: Natural -> TSem (IOSim s) -> STM (IOSim s) ()

newTChan :: STM (IOSim s) (TChan (IOSim s) a)

newBroadcastTChan :: STM (IOSim s) (TChan (IOSim s) a)

dupTChan :: TChan (IOSim s) a -> STM (IOSim s) (TChan (IOSim s) a)

cloneTChan :: TChan (IOSim s) a -> STM (IOSim s) (TChan (IOSim s) a)

readTChan :: TChan (IOSim s) a -> STM (IOSim s) a

tryReadTChan :: TChan (IOSim s) a -> STM (IOSim s) (Maybe a)

peekTChan :: TChan (IOSim s) a -> STM (IOSim s) a

tryPeekTChan :: TChan (IOSim s) a -> STM (IOSim s) (Maybe a)

writeTChan :: TChan (IOSim s) a -> a -> STM (IOSim s) ()

unGetTChan :: TChan (IOSim s) a -> a -> STM (IOSim s) ()

isEmptyTChan :: TChan (IOSim s) a -> STM (IOSim s) Bool

newTVarIO :: a -> IOSim s (TVar (IOSim s) a)

readTVarIO :: TVar (IOSim s) a -> IOSim s a

newTMVarIO :: a -> IOSim s (TMVar (IOSim s) a)

newEmptyTMVarIO :: IOSim s (TMVar (IOSim s) a)

newTQueueIO :: IOSim s (TQueue (IOSim s) a)

newTBQueueIO :: Natural -> IOSim s (TBQueue (IOSim s) a)

newTChanIO :: IOSim s (TChan (IOSim s) a)

newBroadcastTChanIO :: IOSim s (TChan (IOSim s) a)

MonadTraceSTM (IOSim s) Source #

This instance adds a trace when a variable was written, just after the stm transaction was committed.

Traces the first value using dynamic tracing, like traceM does, i.e. with EventDynamic; the string is traced using EventSay.

Instance details

Defined in Control.Monad.IOSim.Types

Methods

traceTVar :: proxy (IOSim s) -> TVar (IOSim s) a -> (Maybe a -> a -> InspectMonadSTM (IOSim s) TraceValue) -> STM (IOSim s) ()

traceTMVar :: proxy (IOSim s) -> TMVar (IOSim s) a -> (Maybe (Maybe a) -> Maybe a -> InspectMonadSTM (IOSim s) TraceValue) -> STM (IOSim s) ()

traceTQueue :: proxy (IOSim s) -> TQueue (IOSim s) a -> (Maybe [a] -> [a] -> InspectMonadSTM (IOSim s) TraceValue) -> STM (IOSim s) ()

traceTBQueue :: proxy (IOSim s) -> TBQueue (IOSim s) a -> (Maybe [a] -> [a] -> InspectMonadSTM (IOSim s) TraceValue) -> STM (IOSim s) ()

traceTSem :: proxy (IOSim s) -> TSem (IOSim s) -> (Maybe Integer -> Integer -> InspectMonadSTM (IOSim s) TraceValue) -> STM (IOSim s) ()

traceTVarIO :: TVar (IOSim s) a -> (Maybe a -> a -> InspectMonadSTM (IOSim s) TraceValue) -> IOSim s ()

traceTMVarIO :: TMVar (IOSim s) a -> (Maybe (Maybe a) -> Maybe a -> InspectMonadSTM (IOSim s) TraceValue) -> IOSim s ()

traceTQueueIO :: TQueue (IOSim s) a -> (Maybe [a] -> [a] -> InspectMonadSTM (IOSim s) TraceValue) -> IOSim s ()

traceTBQueueIO :: TBQueue (IOSim s) a -> (Maybe [a] -> [a] -> InspectMonadSTM (IOSim s) TraceValue) -> IOSim s ()

traceTSemIO :: TSem (IOSim s) -> (Maybe Integer -> Integer -> InspectMonadSTM (IOSim s) TraceValue) -> IOSim s ()

MonadSay (IOSim s) Source #

`IOSim s` instance is strict: the string will be evaluated to normal form, if an exception is encountered it is thrown in the current thread, and the log will contain EventSayEvaluationError.

Instance details

Defined in Control.Monad.IOSim.Types

Methods

say :: String -> IOSim s ()

MonadTest (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

exploreRaces :: IOSim s ()

MonadCatch (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

catch :: Exception e => IOSim s a -> (e -> IOSim s a) -> IOSim s a

catchJust :: Exception e => (e -> Maybe b) -> IOSim s a -> (b -> IOSim s a) -> IOSim s a

try :: Exception e => IOSim s a -> IOSim s (Either e a)

tryJust :: Exception e => (e -> Maybe b) -> IOSim s a -> IOSim s (Either b a)

handle :: Exception e => (e -> IOSim s a) -> IOSim s a -> IOSim s a

handleJust :: Exception e => (e -> Maybe b) -> (b -> IOSim s a) -> IOSim s a -> IOSim s a

onException :: IOSim s a -> IOSim s b -> IOSim s a

bracketOnError :: IOSim s a -> (a -> IOSim s b) -> (a -> IOSim s c) -> IOSim s c

generalBracket :: IOSim s a -> (a -> ExitCase b -> IOSim s c) -> (a -> IOSim s b) -> IOSim s (b, c)

MonadEvaluate (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

evaluate :: a -> IOSim s a

MonadMask (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

mask :: ((forall a. IOSim s a -> IOSim s a) -> IOSim s b) -> IOSim s b

uninterruptibleMask :: ((forall a. IOSim s a -> IOSim s a) -> IOSim s b) -> IOSim s b

mask_ :: IOSim s a -> IOSim s a

uninterruptibleMask_ :: IOSim s a -> IOSim s a

getMaskingState :: IOSim s MaskingState

interruptible :: IOSim s a -> IOSim s a

allowInterrupt :: IOSim s ()

MonadMaskingState (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

MonadThrow (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

throwIO :: Exception e => e -> IOSim s a

bracket :: IOSim s a -> (a -> IOSim s b) -> (a -> IOSim s c) -> IOSim s c

bracket_ :: IOSim s a -> IOSim s b -> IOSim s c -> IOSim s c

finally :: IOSim s a -> IOSim s b -> IOSim s a

annotateIO :: ExceptionAnnotation e => e -> IOSim s a -> IOSim s a

MonadMonotonicTimeNSec (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

getMonotonicTimeNSec :: IOSim s Word64

MonadTime (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

getCurrentTime :: IOSim s UTCTime

MonadDelay (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

threadDelay :: Int -> IOSim s ()

MonadTimer (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

registerDelay :: Int -> IOSim s (TVar (IOSim s) Bool)

timeout :: Int -> IOSim s a -> IOSim s (Maybe a)

MonadUnique (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Associated Types

type Unique (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type Unique (IOSim s) = Unique s

Methods

newUnique :: IOSim s (Unique (IOSim s))

hashUnique :: Unique (IOSim s) -> Int

MonadMonotonicTime (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

getMonotonicTime :: IOSim s Time

MonadDelay (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

threadDelay :: DiffTime -> IOSim s ()

MonadTimer (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

registerDelay :: DiffTime -> IOSim s (TVar (IOSim s) Bool)

registerDelayCancellable :: DiffTime -> IOSim s (STM (IOSim s) TimeoutState, IOSim s ())

timeout :: DiffTime -> IOSim s a -> IOSim s (Maybe a)

PrimMonad (IOSim s) Source #

This provides access to (almost) everything from the primitive package, but don't try to use the MVars as that will not work as expected.

Since: 1.4.1.0

Instance details

Defined in Control.Monad.IOSim.Types

Associated Types

type PrimState (IOSim s)
Instance details Defined in Control.Monad.IOSim.Types type PrimState (IOSim s) = s

Methods

primitive :: (State# (PrimState (IOSim s)) -> (# State# (PrimState (IOSim s)), a #)) -> IOSim s a #

Monoid a => Monoid (IOSim s a) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

mempty :: IOSim s a #

mappend :: IOSim s a -> IOSim s a -> IOSim s a #

mconcat :: [IOSim s a] -> IOSim s a #

Semigroup a => Semigroup (IOSim s a) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

(<>) :: IOSim s a -> IOSim s a -> IOSim s a #

sconcat :: NonEmpty (IOSim s a) -> IOSim s a #

stimes :: Integral b => b -> IOSim s a -> IOSim s a #

NoThunks a => NoThunks (StrictTVar (IOSim s) a) Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

noThunks :: Context -> StrictTVar (IOSim s) a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> StrictTVar (IOSim s) a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (StrictTVar (IOSim s) a) -> String

NoThunks (IOSim s a) Source #

Just like the IO instance, we don't actually check anything here

Instance details

Defined in Control.Monad.IOSim.Types

Methods

noThunks :: Context -> IOSim s a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> IOSim s a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (IOSim s a) -> String

type InspectMVarMonad (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type InspectMVarMonad (IOSim s) = ST s

type MVar (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type MVar (IOSim s)

type Async (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type Async (IOSim s)

type ThreadId (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type ThreadId (IOSim s) = IOSimThreadId

type InspectMonadSTM (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type InspectMonadSTM (IOSim s) = ST s

type STM (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type STM (IOSim s)

type TArray (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TArray (IOSim s) = TArrayDefault (IOSim s)

type TBQueue (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TBQueue (IOSim s)

type TChan (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TChan (IOSim s) = TChanDefault (IOSim s)

type TMVar (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TMVar (IOSim s) = TMVarDefault (IOSim s)

type TQueue (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TQueue (IOSim s)

type TSem (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TSem (IOSim s) = TSemDefault (IOSim s)

type TVar (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type TVar (IOSim s)

type Unique (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type Unique (IOSim s) = Unique s

type PrimState (IOSim s) Source #

Instance details

Defined in Control.Monad.IOSim.Types

type PrimState (IOSim s) = s

type STMSim = STM Source #

IOSim's STM monad, as IOSim it is parametrised by s, e.g. STMSim s a is monadic expression of type a.

Run simulation

runSim :: (forall s. IOSim s a) -> Either Failure a Source #

IOSim is a pure monad.

runSimOrThrow :: (forall s. IOSim s a) -> a Source #

For quick experiments and tests it is often appropriate and convenient to simply throw failures as exceptions.

runSimStrictShutdown :: (forall s. IOSim s a) -> Either Failure a Source #

Like runSim but fail when the main thread terminates if there are other threads still running or blocked. If one is trying to follow a strict thread clean-up policy then this helps testing for that.

data Failure Source #

Simulation terminated a failure.

Constructors

FailureException SomeException	The main thread terminated with an exception.
FailureDeadlock ![Labelled IOSimThreadId]	The threads all deadlocked.
FailureSloppyShutdown [Labelled IOSimThreadId]	The main thread terminated normally but other threads were still alive, and strict shutdown checking was requested. See `runSimStrictShutdown`.
FailureEvaluation SomeException	An exception was thrown while evaluation the trace. This could be an internal assertion failure of `io-sim` or an unhandled exception in the simulation.
FailureInternal String	An internal failure of the simulator. Please open an issue at https://github.com/input-output-hk/io-sim/issues.

Instances

Instances details

Exception Failure Source #
Instance details Defined in Control.Monad.IOSim Methods toException :: Failure -> SomeException # fromException :: SomeException -> Maybe Failure # displayException :: Failure -> String # backtraceDesired :: Failure -> Bool #
Show Failure Source #
Instance details Defined in Control.Monad.IOSim Methods showsPrec :: Int -> Failure -> ShowS # show :: Failure -> String # showList :: [Failure] -> ShowS #

runSimTrace :: (forall s. IOSim s a) -> SimTrace a Source #

See runSimTraceST below.

runSimTraceST :: IOSim s a -> ST s (SimTrace a) Source #

The most general method of running IOSim is in the lazy ST monad. One can recover failures or the result from SimTrace with traceResult, or access SimEventTypes generated by the computation with traceEvents. A slightly more convenient way is exposed by runSimTrace.

QuickCheck Monadic combinators

monadicIOSim_ :: Testable a => (forall s. PropertyM (IOSim s) a) -> Property Source #

Like https://hackage.haskell.org/package/QuickCheck-2.14.3/docs/Test-QuickCheck-Monadic.html#v:monadicST.

Note: it calls traceResult in non-strict mode, e.g. leaked threads do not cause failures.

Since: 1.4.1.0

monadicIOSim Source #

Arguments

:: (Testable a, forall s. Monad (m s))
=> (SimTrace Property -> Property)	Allows to trace `SimTrace` in counterexamples. The simplest use case is to pass: either (\e -> counterexample (show e) False) id . traceResult False as `monadicIOSim_` does.
-> (forall s a1. m s a1 -> IOSim s a1)	natural transformation from `m` to IOSim` s
-> (forall s. PropertyM (m s) a)
-> Property

A more general version of monadicIOSim_, which:

allows to run in monad stacks build on top of IOSim;
gives more control how to attach debugging information to failed tests.

Note, to use this combinator your monad needs to be defined as:

newtype M s a = M s { runM :: ReaderT State (IOSim s) a }

It's important that `M s` is a monad. For such a monad one you'll need provide a natural transformation: -- the state could also be created as an IOSim computation. nat :: forall s a. State -> M s a -> IOSim s a nat state m = runStateT (runM m) state

Since: 1.4.1.0

runIOSimGen :: (SimTrace a -> Property) -> (forall s. Gen (IOSim s a)) -> Gen Property Source #

Like <runSTGen https://hackage.haskell.org/package/QuickCheck-2.14.3/docs/Test-QuickCheck-Monadic.html#v:runSTGen>.

Since: 1.4.1.0

Explore races using IOSimPOR

monadicIOSimPOR_ :: Testable a => (forall s. PropertyM (IOSim s) a) -> Property Source #

Like <monadicST https://hackage.haskell.org/package/QuickCheck-2.14.3/docs/Test-QuickCheck-Monadic.html#v:monadicST>, but using IOSimPOR schedule exploration.

Note: it calls traceResult in non-strict mode, e.g. leaked threads do not cause failures.

testProperty "example" $
  monadicIOSimPOR_ $ do
    x <- run (pure (1 :: Int))
    assert (x == 1)

Since: 1.10.0.0

monadicIOSimPOR :: (Testable a, forall s. Monad (m s)) => (ExplorationOptions -> ExplorationOptions) -> (Maybe (SimTrace Property) -> SimTrace Property -> Property) -> (forall s a1. m s a1 -> IOSim s a1) -> (forall s. PropertyM (m s) a) -> Property Source #

A IOSimPOR variant of monadicIOSim_, which:

explores alternative schedules using exploreSimTrace;
allows to run in monad stacks build on top of IOSim;
gives more control how to attach debugging information to failed tests.

Note, to use this combinator your monad needs to be defined as:

newtype M s a = M { runM :: ReaderT State (IOSim s) a }

It's important that `M s` is a monad. For such a monad you'll need to provide a natural transformation: -- the state could also be created as an IOSim computation. nat :: forall s a. State -> M s a -> IOSim s a nat state m = runStateT (runM m) state

Since: 1.10.0.0

runIOSimPORGen :: Testable test => (ExplorationOptions -> ExplorationOptions) -> (Maybe (SimTrace a) -> SimTrace a -> test) -> (forall s. Gen (IOSim s a)) -> Gen Property Source #

Like <runSTGen https://hackage.haskell.org/package/QuickCheck-2.14.3/docs/Test-QuickCheck-Monadic.html#v:runSTGen>, but evaluates generated simulations using exploreSimTrace.

The callback receives the previously passing trace (if any) and the current trace being checked.

Since: 1.10.0.0

IOSimPOR is a different interpreter of IOSim which has the ability to discover race conditions and replay the simulation using a schedule which reverts them. For extended documentation how to use it see here.

IOSimPOR only discovers races between events which happen in the same time slot. In IOSim and IOSimPOR time only moves explicitly through timer events, e.g. things like threadDelay, registerDelay or the NonStandard API. The usual QuickCheck techniques can help explore different schedules of threads too.

exploreSimTrace Source #

Arguments

:: forall a test. Testable test
=> (ExplorationOptions -> ExplorationOptions)	modify default exploration options
-> (forall s. IOSim s a)	a simulation to run
-> (Maybe (SimTrace a) -> SimTrace a -> test)	a callback which receives the previous trace (e.g. before reverting a race condition) and current trace
-> Property

Execute a simulation, discover & revert races. Note that this will execute the simulation multiple times with different schedules, and thus it's much more costly than a simple runSimTrace (also the simulation environments has much more state to track and hence it is slower).

On property failure it will show the failing schedule (ScheduleControl) which can be passed to controlSimTrace to reproduce the failure without discovering the schedule.

controlSimTrace Source #

Arguments

:: Maybe Int	limit on the computation time allowed per scheduling step, for catching infinite loops etc.
-> ScheduleControl	a schedule to replay note: must be either `ControlDefault` or `ControlAwait`.
-> (forall s. IOSim s a)	a simulation to run
-> SimTrace a

Run a simulation using a given schedule. This is useful to reproduce failing cases without exploring the races.

data ScheduleMod Source #

A schedule modification inserted at given execution step.

Constructors

ScheduleMod

Fields

scheduleModTarget :: StepId
Step at which the ScheduleMod is activated.
scheduleModControl :: ScheduleControl
ScheduleControl at the activation step. It is needed by extendScheduleControl when combining the discovered schedule with the initial one.
scheduleModInsertion :: [StepId]
Series of steps which are executed at the target step. This *includes* the target step, not necessarily as the last step.

Instances

Instances details

Show ScheduleMod Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods showsPrec :: Int -> ScheduleMod -> ShowS # show :: ScheduleMod -> String # showList :: [ScheduleMod] -> ShowS #
Eq ScheduleMod Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods (==) :: ScheduleMod -> ScheduleMod -> Bool # (/=) :: ScheduleMod -> ScheduleMod -> Bool #
Ord ScheduleMod Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods compare :: ScheduleMod -> ScheduleMod -> Ordering # (<) :: ScheduleMod -> ScheduleMod -> Bool # (<=) :: ScheduleMod -> ScheduleMod -> Bool # (>) :: ScheduleMod -> ScheduleMod -> Bool # (>=) :: ScheduleMod -> ScheduleMod -> Bool # max :: ScheduleMod -> ScheduleMod -> ScheduleMod # min :: ScheduleMod -> ScheduleMod -> ScheduleMod #

data ScheduleControl Source #

Modified execution schedule.

Constructors

ControlDefault	default scheduling mode
ControlAwait [ScheduleMod]	if the current control is `ControlAwait`, the normal scheduling will proceed, until the thread found in the first `ScheduleMod` reaches the given step. At this point the thread is put to sleep, until after all the steps are followed.
ControlFollow [StepId] [ScheduleMod]	follow the steps then continue with schedule modifications. This control is set by `followControl` when `controlTargets` returns true.

Instances

Instances details

Show ScheduleControl Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods showsPrec :: Int -> ScheduleControl -> ShowS # show :: ScheduleControl -> String # showList :: [ScheduleControl] -> ShowS #
Eq ScheduleControl Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods (==) :: ScheduleControl -> ScheduleControl -> Bool # (/=) :: ScheduleControl -> ScheduleControl -> Bool #
Ord ScheduleControl Source #
Instance details Defined in Control.Monad.IOSimPOR.Types Methods compare :: ScheduleControl -> ScheduleControl -> Ordering # (<) :: ScheduleControl -> ScheduleControl -> Bool # (<=) :: ScheduleControl -> ScheduleControl -> Bool # (>) :: ScheduleControl -> ScheduleControl -> Bool # (>=) :: ScheduleControl -> ScheduleControl -> Bool # max :: ScheduleControl -> ScheduleControl -> ScheduleControl # min :: ScheduleControl -> ScheduleControl -> ScheduleControl #

Exploration options

type ExplorationSpec = ExplorationOptions -> ExplorationOptions Source #

data ExplorationOptions Source #

Race exploration options.

Constructors

ExplorationOptions

Fields

explorationScheduleBound :: Int
This is an upper bound on the number of schedules with race reversals that will be explored; a bound of zero means that the default schedule will be explored, but no others. Setting the bound to zero makes IOSimPOR behave rather like IOSim, in that only one schedule is explored, but (a) IOSimPOR is considerably slower, because it still collects information on potential races, and (b) the IOSimPOR schedule is different (based on priorities, in contrast to IOSim's round-robin), and plays better with shrinking.
The default value is `100`.
explorationBranching :: Int
The branching factor. This is the number of alternative schedules that IOSimPOR tries to run, per race reversal. With the default parameters, IOSimPOR will try to reverse the first 33 (100 div 3) races discovered using the default schedule, then (if 33 or more races are discovered), for each such reversed race, will run the reversal and try to reverse two more races in the resulting schedule. A high branching factor will explore more combinations of reversing fewer races, within the overall schedule bound. A branching factor of one will explore only schedules resulting from a single race reversal (unless there are fewer races available to be reversed than the schedule bound).
The default value is `3`.
explorationStepTimelimit :: Maybe Int
Limit on the computation time allowed per scheduling step, for catching infinite loops etc.
The default value is Nothing.
explorationReplay :: Maybe ScheduleControl
A schedule to replay.
The default value is Nothing.
explorationDebugLevel :: Int
Log detailed trace to stderr containing information on discovered races. The trace does not contain the result of the simulation, unless one will do that explicitly inside the simulation.
level 0: don't show any output, level 1: show simulation trace with discovered schedules level 2: show simulation trace with discovered schedules and races
NOTE: discovered schedules & races are not exposed to the user in the callback of exploreSimTrace or in the output of controlSimTrace.

Instances

Instances details

Show ExplorationOptions Source #
Instance details Defined in Control.Monad.IOSim.Types Methods showsPrec :: Int -> ExplorationOptions -> ShowS # show :: ExplorationOptions -> String # showList :: [ExplorationOptions] -> ShowS #

stdExplorationOptions :: ExplorationOptions Source #

withScheduleBound :: Int -> ExplorationSpec Source #

withBranching :: Int -> ExplorationSpec Source #

withStepTimelimit :: Int -> ExplorationSpec Source #

withReplay :: ScheduleControl -> ExplorationSpec Source #

Lift ST computations

liftST :: ST s a -> IOSim s a Source #

Lift an ST computation to IOSim.

Note: you can use MonadST to lift ST computations, this is a more convenient function just for IOSim.

Simulation time

setCurrentTime :: UTCTime -> IOSim s () Source #

Set the current wall clock time for the thread's clock domain.

unshareClock :: IOSim s () Source #

Put the thread into a new wall clock domain, not shared with the parent thread. Changing the wall clock time in the new clock domain will not affect the other clock of other threads. All threads forked by this thread from this point onwards will share the new clock domain.

Simulation trace

type SimTrace a = Trace (SimResult a) SimEvent Source #

A type alias for IOSim simulation trace. It comes with useful pattern synonyms.

newtype Time #

Constructors

Time DiffTime

Instances

Instances details

NFData Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Methods

rnf :: Time -> () #

Generic Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Associated Types

type Rep Time
Instance details Defined in Control.Monad.Class.MonadTime.SI type Rep Time = D1 ('MetaData "Time" "Control.Monad.Class.MonadTime.SI" "io-classes-1.10.0.0-inplace-si-timers" 'True) (C1 ('MetaCons "Time" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DiffTime)))

Methods

from :: Time -> Rep Time x #

to :: Rep Time x -> Time #

Show Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Methods

showsPrec :: Int -> Time -> ShowS #

show :: Time -> String #

showList :: [Time] -> ShowS #

Eq Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Methods

(==) :: Time -> Time -> Bool #

(/=) :: Time -> Time -> Bool #

Ord Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Methods

compare :: Time -> Time -> Ordering #

(<) :: Time -> Time -> Bool #

(<=) :: Time -> Time -> Bool #

(>) :: Time -> Time -> Bool #

(>=) :: Time -> Time -> Bool #

max :: Time -> Time -> Time #

min :: Time -> Time -> Time #

NoThunks Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

Methods

noThunks :: Context -> Time -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Time -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Time -> String

type Rep Time #

Instance details

Defined in Control.Monad.Class.MonadTime.SI

type Rep Time = D1 ('MetaData "Time" "Control.Monad.Class.MonadTime.SI" "io-classes-1.10.0.0-inplace-si-timers" 'True) (C1 ('MetaCons "Time" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DiffTime)))

data Trace a b Source #

A cons list with polymorphic nil.

Trace Void a is an infinite stream
Trace () a is isomorphic to [a]

Usually used with a being a non empty sum type.

Constructors

Cons b (Trace a b)
Nil a

Bundled Patterns

pattern SimTrace :: Time -> IOSimThreadId -> Maybe ThreadLabel -> SimEventType -> SimTrace a -> SimTrace a
pattern SimPORTrace :: Time -> IOSimThreadId -> Int -> Maybe ThreadLabel -> SimEventType -> SimTrace a -> SimTrace a
pattern TraceDeadlock :: Time -> [Labelled IOSimThreadId] -> SimTrace a
pattern TraceLoop :: SimTrace a
pattern TraceMainReturn :: Time -> Labelled IOSimThreadId -> a -> [Labelled IOSimThreadId] -> SimTrace a
pattern TraceMainException :: Time -> Labelled IOSimThreadId -> SomeException -> [Labelled IOSimThreadId] -> SimTrace a
pattern TraceRacesFound :: [ScheduleControl] -> SimTrace a -> SimTrace a
pattern TraceInternalError :: String -> SimTrace a

Instances

Instances details

Bifoldable Trace Source #
Instance details Defined in Data.List.Trace Methods bifold :: Monoid m => Trace m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Trace a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Trace a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Trace a b -> c #
Bifunctor Trace Source #
Instance details Defined in Data.List.Trace Methods bimap :: (a -> b) -> (c -> d) -> Trace a c -> Trace b d # first :: (a -> b) -> Trace a c -> Trace b c # second :: (b -> c) -> Trace a b -> Trace a c #
Bitraversable Trace Source #
Instance details Defined in Data.List.Trace Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Trace a b -> f (Trace c d) #
Eq a => Eq1 (Trace a) Source #
Instance details Defined in Data.List.Trace Methods liftEq :: (a0 -> b -> Bool) -> Trace a a0 -> Trace a b -> Bool #
Ord a => Ord1 (Trace a) Source #
Instance details Defined in Data.List.Trace Methods liftCompare :: (a0 -> b -> Ordering) -> Trace a a0 -> Trace a b -> Ordering #
Show a => Show1 (Trace a) Source #
Instance details Defined in Data.List.Trace Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Trace a a0 -> ShowS # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Trace a a0] -> ShowS #
Monoid a => Alternative (Trace a) Source #
Instance details Defined in Data.List.Trace Methods empty :: Trace a a0 # (<\|>) :: Trace a a0 -> Trace a a0 -> Trace a a0 # some :: Trace a a0 -> Trace a [a0] # many :: Trace a a0 -> Trace a [a0] #
Monoid a => Applicative (Trace a) Source #
Instance details Defined in Data.List.Trace Methods pure :: a0 -> Trace a a0 # (<>) :: Trace a (a0 -> b) -> Trace a a0 -> Trace a b # liftA2 :: (a0 -> b -> c) -> Trace a a0 -> Trace a b -> Trace a c # (>) :: Trace a a0 -> Trace a b -> Trace a b # (<*) :: Trace a a0 -> Trace a b -> Trace a a0 #
Functor (Trace a) Source #
Instance details Defined in Data.List.Trace Methods fmap :: (a0 -> b) -> Trace a a0 -> Trace a b # (<$) :: a0 -> Trace a b -> Trace a a0 #
Monoid a => Monad (Trace a) Source #
Instance details Defined in Data.List.Trace Methods (>>=) :: Trace a a0 -> (a0 -> Trace a b) -> Trace a b # (>>) :: Trace a a0 -> Trace a b -> Trace a b # return :: a0 -> Trace a a0 #
Monoid a => MonadPlus (Trace a) Source #
Instance details Defined in Data.List.Trace Methods mzero :: Trace a a0 # mplus :: Trace a a0 -> Trace a a0 -> Trace a a0 #
Monoid a => MonadFail (Trace a) Source #
Instance details Defined in Data.List.Trace Methods fail :: String -> Trace a a0 #
Monoid a => MonadFix (Trace a) Source #
Instance details Defined in Data.List.Trace Methods mfix :: (a0 -> Trace a a0) -> Trace a a0 #
Monoid a => Monoid (Trace a b) Source #
Instance details Defined in Data.List.Trace Methods mempty :: Trace a b # mappend :: Trace a b -> Trace a b -> Trace a b # mconcat :: [Trace a b] -> Trace a b #
Semigroup a => Semigroup (Trace a b) Source #
Instance details Defined in Data.List.Trace Methods (<>) :: Trace a b -> Trace a b -> Trace a b # sconcat :: NonEmpty (Trace a b) -> Trace a b # stimes :: Integral b0 => b0 -> Trace a b -> Trace a b #
(Show b, Show a) => Show (Trace a b) Source #
Instance details Defined in Data.List.Trace Methods showsPrec :: Int -> Trace a b -> ShowS # show :: Trace a b -> String # showList :: [Trace a b] -> ShowS #
(Eq b, Eq a) => Eq (Trace a b) Source #
Instance details Defined in Data.List.Trace Methods (==) :: Trace a b -> Trace a b -> Bool # (/=) :: Trace a b -> Trace a b -> Bool #
(Ord b, Ord a) => Ord (Trace a b) Source #
Instance details Defined in Data.List.Trace Methods compare :: Trace a b -> Trace a b -> Ordering # (<) :: Trace a b -> Trace a b -> Bool # (<=) :: Trace a b -> Trace a b -> Bool # (>) :: Trace a b -> Trace a b -> Bool # (>=) :: Trace a b -> Trace a b -> Bool # max :: Trace a b -> Trace a b -> Trace a b # min :: Trace a b -> Trace a b -> Trace a b #

traceEvents :: SimTrace a -> [(Time, IOSimThreadId, Maybe ThreadLabel, SimEventType)] Source #

Turn SimTrace into a list of timestamped events.

traceResult Source #

Arguments

:: Bool	if True the simulation will fail if there are any threads which didn't terminated when the main thread terminated.
-> SimTrace a	simulation trace
-> Either Failure a

Fold through the trace and return either Failure or a simulation result, i.e. the return value of the main thread.

data SimResult a Source #

A result type of a simulation.

Constructors

MainReturn !Time !(Labelled IOSimThreadId) a ![Labelled IOSimThreadId]	Return value of the main thread.
MainException !Time !(Labelled IOSimThreadId) SomeException ![Labelled IOSimThreadId]	Exception thrown by the main thread.
Deadlock !Time ![Labelled IOSimThreadId]	Deadlock discovered in the simulation. Deadlocks are discovered if simply the simulation cannot do any progress in a given time slot and there's no event which would advance the time.
Loop	Only returned by IOSimPOR when a step execution took longer than `explorationStepTimelimit` was exceeded.
InternalError String	An `IOSim` bug, please report to https://github.com/input-output-hk/io-sim

Instances

Instances details

Functor SimResult Source #
Instance details Defined in Control.Monad.IOSim.Types Methods fmap :: (a -> b) -> SimResult a -> SimResult b # (<$) :: a -> SimResult b -> SimResult a #
Show a => Show (SimResult a) Source #
Instance details Defined in Control.Monad.IOSim.Types Methods showsPrec :: Int -> SimResult a -> ShowS # show :: SimResult a -> String # showList :: [SimResult a] -> ShowS #

data SimEvent Source #

Trace is a recursive data type, it is the trace of a IOSim computation. The trace will contain information about thread scheduling, blocking on TVars, and other internal state changes of IOSim. More importantly it also supports traces generated by the computation with say (which corresponds to using putStrLn in IO), traceEventM, or dynamically typed traces with traceM (which generalise the base library traceM)

It also contains information on discovered races.

Constructors

SimEvent	Used when using `IOSim`.
Fields seTime :: !Time seThreadId :: !IOSimThreadId seThreadLabel :: !(Maybe ThreadLabel) seType :: !SimEventType
SimPOREvent	Only used for IOSimPOR
Fields seTime :: !Time seThreadId :: !IOSimThreadId seStep :: !Int seThreadLabel :: !(Maybe ThreadLabel) seType :: !SimEventType
SimRacesFound [ScheduleControl]	Only used for IOSimPOR

Instances

Instances details

Generic SimEvent Source #

Instance details

Defined in Control.Monad.IOSim.Types

Associated Types

type Rep SimEvent

Instance details

Defined in Control.Monad.IOSim.Types

Methods

from :: SimEvent -> Rep SimEvent x #

to :: Rep SimEvent x -> SimEvent #

Show SimEvent Source #

Instance details

Defined in Control.Monad.IOSim.Types

Methods

showsPrec :: Int -> SimEvent -> ShowS #

show :: SimEvent -> String #

showList :: [SimEvent] -> ShowS #

type Rep SimEvent Source #

Instance details

Defined in Control.Monad.IOSim.Types

data SimEventType Source #

Events recorded by the simulation.

Constructors

EventSay String	holds value of `say`
EventSayEvaluationError SomeException	holds error resulted from evaluation of the expression passed to `say` to NF.
EventLog Dynamic	holds a dynamic value of `traceM`
EventLogEvaluationError SomeException	holds error resulted from evaluation of the expression passed to `traceM` to WHNF.
EventMask MaskingState	masking state changed
EventThrow SomeException	throw exception
EventThrowTo SomeException IOSimThreadId	throw asynchronous exception (`throwTo`)
EventThrowToBlocked	the thread which executed `throwTo` is blocked
EventThrowToWakeup	the thread which executed `throwTo` is woken up
EventThrowToUnmasked (Labelled IOSimThreadId)	a target thread of `throwTo` unmasked its exceptions, this is paired with `EventThrowToWakeup` for threads which were blocked on `throwTo`
EventEvaluationError SomeException
EventEvaluationSuccess
EventThreadForked IOSimThreadId	forked a thread
EventThreadFinished	thread terminated normally
EventThreadUnhandled SomeException	thread terminated by an unhandled exception
EventUniqueCreated Integer	created the n-th `Unique`
EventTxCommitted	committed STM transaction
Fields [Labelled TVarId] stm tx wrote to these [Labelled TVarId] and created these (Maybe Effect) effect performed (only for `IOSimPOR`) \| aborted an STM transaction (by an exception) For IOSimPOR it also holds performed effect.
EventTxAborted (Maybe Effect)
EventTxBlocked	STM transaction blocked (due to `retry`)
Fields [Labelled TVarId] (Maybe Effect) effect performed (only for `IOSimPOR`)
EventTxWakeup [Labelled TVarId]	changed vars causing retry
EventUnblocked [IOSimThreadId]	unblocked threads by a committed STM transaction
EventThreadDelay TimeoutId Time	thread delayed
EventThreadDelayFired TimeoutId	thread woken up after a delay
EventTimeoutCreated TimeoutId IOSimThreadId Time	new timeout created (via `timeout`)
EventTimeoutFired TimeoutId	timeout fired
EventRegisterDelayCreated TimeoutId TVarId Time	registered delay (via `registerDelay`)
EventRegisterDelayFired TimeoutId	registered delay fired
EventTimerCreated TimeoutId TVarId Time	a new `Timeout` created (via `newTimeout`)
EventTimerCancelled TimeoutId	a `Timeout` was cancelled (via `cancelTimeout`)
EventTimerFired TimeoutId	a `Timeout` fired
EventThreadStatus	event traced when `threadStatus` is executed
Fields IOSimThreadId current thread IOSimThreadId queried thread
EventSimStart ScheduleControl	IOSimPOR event: new execution started exploring the given schedule.
EventThreadSleep	IOSimPOR event: the labelling thread was runnable, but its execution was delayed, until `EventThreadWake`. Event inserted to mark a difference between a failed trace and a similar passing trace.
EventThreadWake	IOSimPOR event: marks when the thread was rescheduled by IOSimPOR
EventDeschedule Deschedule	IOSim and IOSimPOR event: a thread was descheduled
EventFollowControl ScheduleControl	IOSimPOR event: following given schedule
EventAwaitControl StepId ScheduleControl	IOSimPOR event: thread delayed to follow the given schedule
EventPerformAction StepId	IOSimPOR event: perform action of the given step
EventReschedule ScheduleControl	IOSimPOR event: reschedule a thread following the given `ScheduleControl`
EventEffect VectorClock Effect	IOSimPOR event: executed effect; Useful for debugging IOSimPOR or showing compact information about thread execution.
EventRaces Races	IOSimPOR event: races. Races are updated while we execute a simulation. Useful for debugging IOSimPOR.

Instances

Instances details

Show SimEventType Source #
Instance details Defined in Control.Monad.IOSim.Types Methods showsPrec :: Int -> SimEventType -> ShowS # show :: SimEventType -> String # showList :: [SimEventType] -> ShowS #

type ThreadLabel = String Source #

data IOSimThreadId Source #

A thread id.

IOSimPOR: RacyThreadId indicates that this thread is taken into account when discovering races. A thread is marked as racy iff exploreRaces was executed in it or it's a thread forked by a racy thread.

Constructors

RacyThreadId [Int]	A racy thread (`IOSimPOR` only), shown in the trace with curly braces, e.g. `Thread {2,3}`.
ThreadId [Int]	A non racy thread. They have higher priority than racy threads in `IOSimPOR` scheduler.

Instances

Instances details

NFData IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

rnf :: IOSimThreadId -> () #

Generic IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Associated Types

type Rep IOSimThreadId

Instance details

Defined in Control.Monad.IOSim.CommonTypes

type Rep IOSimThreadId = D1 ('MetaData "IOSimThreadId" "Control.Monad.IOSim.CommonTypes" "io-sim-1.10.0.0-inplace" 'False) (C1 ('MetaCons "RacyThreadId" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int])) :+: C1 ('MetaCons "ThreadId" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int])))

Methods

from :: IOSimThreadId -> Rep IOSimThreadId x #

to :: Rep IOSimThreadId x -> IOSimThreadId #

Show IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

showsPrec :: Int -> IOSimThreadId -> ShowS #

show :: IOSimThreadId -> String #

showList :: [IOSimThreadId] -> ShowS #

Eq IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

(==) :: IOSimThreadId -> IOSimThreadId -> Bool #

(/=) :: IOSimThreadId -> IOSimThreadId -> Bool #

Ord IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

compare :: IOSimThreadId -> IOSimThreadId -> Ordering #

(<) :: IOSimThreadId -> IOSimThreadId -> Bool #

(<=) :: IOSimThreadId -> IOSimThreadId -> Bool #

(>) :: IOSimThreadId -> IOSimThreadId -> Bool #

(>=) :: IOSimThreadId -> IOSimThreadId -> Bool #

max :: IOSimThreadId -> IOSimThreadId -> IOSimThreadId #

min :: IOSimThreadId -> IOSimThreadId -> IOSimThreadId #

Hashable IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

hashWithSalt :: Int -> IOSimThreadId -> Int #

hash :: IOSimThreadId -> Int #

NoThunks IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

noThunks :: Context -> IOSimThreadId -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> IOSimThreadId -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy IOSimThreadId -> String

type Rep IOSimThreadId Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

type Rep IOSimThreadId = D1 ('MetaData "IOSimThreadId" "Control.Monad.IOSim.CommonTypes" "io-sim-1.10.0.0-inplace" 'False) (C1 ('MetaCons "RacyThreadId" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int])) :+: C1 ('MetaCons "ThreadId" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int])))

data Labelled a Source #

A labelled value.

For example labelThread or labelTVar will insert a label to IOSimThreadId (or TVarId).

Constructors

Labelled
Fields l_labelled :: !a l_label :: !(Maybe String)

Instances

Instances details

Functor Labelled Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

fmap :: (a -> b) -> Labelled a -> Labelled b #

(<$) :: a -> Labelled b -> Labelled a #

Generic (Labelled a) Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Associated Types

type Rep (Labelled a)

Instance details

Defined in Control.Monad.IOSim.CommonTypes

type Rep (Labelled a) = D1 ('MetaData "Labelled" "Control.Monad.IOSim.CommonTypes" "io-sim-1.10.0.0-inplace" 'False) (C1 ('MetaCons "Labelled" 'PrefixI 'True) (S1 ('MetaSel ('Just "l_labelled") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "l_label") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe String))))

Methods

from :: Labelled a -> Rep (Labelled a) x #

to :: Rep (Labelled a) x -> Labelled a #

Show a => Show (Labelled a) Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

showsPrec :: Int -> Labelled a -> ShowS #

show :: Labelled a -> String #

showList :: [Labelled a] -> ShowS #

Eq a => Eq (Labelled a) Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

(==) :: Labelled a -> Labelled a -> Bool #

(/=) :: Labelled a -> Labelled a -> Bool #

Ord a => Ord (Labelled a) Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

Methods

compare :: Labelled a -> Labelled a -> Ordering #

(<) :: Labelled a -> Labelled a -> Bool #

(<=) :: Labelled a -> Labelled a -> Bool #

(>) :: Labelled a -> Labelled a -> Bool #

(>=) :: Labelled a -> Labelled a -> Bool #

max :: Labelled a -> Labelled a -> Labelled a #

min :: Labelled a -> Labelled a -> Labelled a #

type Rep (Labelled a) Source #

Instance details

Defined in Control.Monad.IOSim.CommonTypes

type Rep (Labelled a) = D1 ('MetaData "Labelled" "Control.Monad.IOSim.CommonTypes" "io-sim-1.10.0.0-inplace" 'False) (C1 ('MetaCons "Labelled" 'PrefixI 'True) (S1 ('MetaSel ('Just "l_labelled") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "l_label") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe String))))

data Unique (s :: k) Source #

Abstract unique symbols à la Data.Unique.

Instances

Instances details

NFData (Unique s) Source #
Instance details Defined in Control.Monad.IOSim.CommonTypes Methods rnf :: Unique s -> () #
Eq (Unique s) Source #
Instance details Defined in Control.Monad.IOSim.CommonTypes Methods (==) :: Unique s -> Unique s -> Bool # (/=) :: Unique s -> Unique s -> Bool #
Ord (Unique s) Source #
Instance details Defined in Control.Monad.IOSim.CommonTypes Methods compare :: Unique s -> Unique s -> Ordering # (<) :: Unique s -> Unique s -> Bool # (<=) :: Unique s -> Unique s -> Bool # (>) :: Unique s -> Unique s -> Bool # (>=) :: Unique s -> Unique s -> Bool # max :: Unique s -> Unique s -> Unique s # min :: Unique s -> Unique s -> Unique s #
Hashable (Unique s) Source #
Instance details Defined in Control.Monad.IOSim.CommonTypes Methods hashWithSalt :: Int -> Unique s -> Int # hash :: Unique s -> Int #

Dynamic Tracing

traceM :: Typeable a => a -> IOSim s () Source #

IOSim has the ability to store any Typeable value in its trace which can then be recovered with selectTraceEventsDynamic or selectTraceEventsDynamic'.

Note: traceM evaluates the a to WHNF, exceptions are thrown by the current thread and the trace will include EventLogEvaluationError.

traceSTM :: Typeable a => a -> STMSim s () Source #

Trace a value, in the same was as traceM does, but from the STM monad. This is primarily useful for debugging.

Note: traceSTM evaluates the a to WHNF, if exception is thrown, the trace will end with TraceException.

Pretty printers

ppTrace :: Show a => SimTrace a -> String Source #

Pretty print simulation trace.

Note: this is not a streaming function, it will evaluate the whole trace before printing it. If you need to print a very large trace, you might want to use

ppTrace show (ppSimEvent 0 0 0)

ppTrace_ :: Trace a SimEvent -> String Source #

Like ppTrace but does not show the result value.

ppEvents :: [(Time, IOSimThreadId, Maybe ThreadLabel, SimEventType)] -> String Source #

Pretty print a timestamped event.

ppSimEvent Source #

Arguments

:: Int	width of the time
-> Int	width of thread id
-> Int	width of thread label
-> SimEvent
-> String

Pretty print a SimEvent.

ppDebug :: SimTrace a -> x -> x Source #

Trace each event using trace; this is useful when a trace ends with a pure error, e.g. an assertion.

Selectors

list selectors

selectTraceEvents :: (Time -> SimEventType -> Maybe b) -> SimTrace a -> [b] Source #

Select events according to the predicate function. It throws an error if the simulation ends with Failure.

selectTraceEvents' :: (Time -> SimEventType -> Maybe b) -> Trace a SimEvent -> [b] Source #

Like selectTraceEvents, but it returns even if the simulation trace ends with Failure. It also works with any return type, not only SimResult like selectTraceEvents does.

selectTraceEventsDynamic :: forall a b. Typeable b => SimTrace a -> [b] Source #

Select all the traced values matching the expected type. It relies on the sim's dynamic trace facility.

For convenience, it throws exceptions for abnormal sim termination.

selectTraceEventsDynamicWithTime :: forall a b. Typeable b => SimTrace a -> [(Time, b)] Source #

Like selectTraceEventsDynamic but it also captures time of the trace event.

selectTraceEventsDynamic' :: forall a b. Typeable b => Trace a SimEvent -> [b] Source #

Like selectTraceEventsDynamic but it returns even if the simulation trace ends with Failure. It also works with any return type, not only SimResult like selectTraceEventsDynamic does.

selectTraceEventsDynamicWithTime' :: forall a b. Typeable b => Trace a SimEvent -> [(Time, b)] Source #

Like selectTraceEventsDynamicWithTime' but it also captures time of the trace event. It also works with any return type, not only SimResult like selectTraceEventsDynamicWithTime does.

selectTraceEventsSay :: SimTrace a -> [String] Source #

Get a trace of EventSay.

For convenience, it throws exceptions for abnormal sim termination.

selectTraceEventsSayWithTime :: SimTrace a -> [(Time, String)] Source #

Like selectTraceEventsSay but it also captures time of the trace event.

selectTraceEventsSay' :: Trace a SimEvent -> [String] Source #

Like selectTraceEventsSay but it returns even if the simulation trace ends with Failure. It also works with any return type, not only SimResult like selectTraceEventsSay does.

selectTraceEventsSayWithTime' :: Trace a SimEvent -> [(Time, String)] Source #

Like selectTraceEventsSay' but it also captures time of the trace event.

selectTraceRaces :: SimTrace a -> [ScheduleControl] Source #