Test.DejaFu.Conc.Internal.Threading

Operations and types for threads. This module is NOT considered to form part of the public interface of this library.

Threads

type Threads n = Map ThreadId (Thread n)

Threads are stored in a map index by ThreadId.

data Thread n

All the state of a thread.

Constructors

Thread

Fields

• _continuation :: Action n

  The next action to execute.

• _blocking :: Maybe BlockedOn

  The state of any blocks.

• _handlers :: [Handler n]

  Stack of exception handlers

• _masking :: MaskingState

  The exception masking state.

• _bound :: Maybe (BoundThread n (Action n))

  State for the associated bound thread, if it exists.

mkthread :: Action n -> Thread n

Construct a thread with just one action

Blocking

data BlockedOn

A BlockedOn is used to determine what sort of variable a thread is blocked on.

Constructors

OnMVarFull MVarId

OnMVarEmpty MVarId

OnTVar [TVarId]

OnMask ThreadId

Instances

Eq BlockedOn

Defined in Test.DejaFu.Conc.Internal.Threading

Methods

(==) :: BlockedOn -> BlockedOn -> Bool

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

(~=) :: Thread n -> BlockedOn -> Bool

Determine if a thread is blocked in a certain way.

Exceptions

data Handler n

An exception handler.

Constructors

forall e.Exception e => Handler MaskingState (e -> Action n)

propagate :: HasCallStack => SomeException -> ThreadId -> Threads n -> Maybe (Threads n)

Propagate an exception upwards, finding the closest handler which can deal with it.

interruptible :: Thread n -> Bool

Check if a thread can be interrupted by an exception.

catching :: (Exception e, HasCallStack) => (e -> Action n) -> ThreadId -> Threads n -> Threads n

Register a new exception handler.

uncatching :: HasCallStack => ThreadId -> Threads n -> Threads n

Remove the most recent exception handler.

except :: HasCallStack => MaskingState -> Action n -> [Handler n] -> ThreadId -> Threads n -> Threads n

Raise an exception in a thread.

mask :: HasCallStack => MaskingState -> ThreadId -> Threads n -> Threads n

Set the masking state of a thread.

Manipulating threads

goto :: HasCallStack => Action n -> ThreadId -> Threads n -> Threads n

Replace the Action of a thread.

launch :: HasCallStack => ThreadId -> ThreadId -> ((forall b. ModelConc n b -> ModelConc n b) -> Action n) -> Threads n -> Threads n

Start a thread with the given ID, inheriting the masking state from the parent thread. This ID must not already be in use!

launch' :: HasCallStack => MaskingState -> ThreadId -> ((forall b. ModelConc n b -> ModelConc n b) -> Action n) -> Threads n -> Threads n

Start a thread with the given ID and masking state. This must not already be in use!

block :: HasCallStack => BlockedOn -> ThreadId -> Threads n -> Threads n

Block a thread.

wake :: BlockedOn -> Threads n -> (Threads n, [ThreadId])

Unblock all threads waiting on the appropriate block. For TVar blocks, this will wake all threads waiting on at least one of the given TVars.

Bound threads

makeBound :: (MonadDejaFu n, HasCallStack) => n (BoundThread n (Action n)) -> ThreadId -> Threads n -> n (Threads n)

Turn a thread into a bound thread.

kill :: (MonadDejaFu n, HasCallStack) => ThreadId -> Threads n -> n (Threads n)

Kill a thread and remove it from the thread map.

If the thread is bound, the worker thread is cleaned up.

runLiftedAct :: MonadDejaFu n => ThreadId -> Threads n -> n (Action n) -> n (Action n)

Run an action.

If the thread is bound, the action is run in the worker thread.