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 r = Map ThreadId (Thread n r)

Threads are stored in a map index by ThreadId.

data Thread n r

All the state of a thread.

Constructors

Thread

Fields

• _continuation :: Action n r

  The next action to execute.

• _blocking :: Maybe BlockedOn

  The state of any blocks.

• _handlers :: [Handler n r]

  Stack of exception handlers

• _masking :: MaskingState

  The exception masking state.

• _bound :: Maybe (BoundThread n r)

  State for the associated bound thread, if it exists.

data BoundThread n r

The state of a bound thread.

Constructors

BoundThread

Fields

• _runboundIO :: MVar n (n (Action n r))

  Run an IO action in the bound thread by writing to this.

• _getboundIO :: MVar n (Action n r)

  Get the result of the above by reading from this.

• _boundTId :: ThreadId n

  Thread ID

mkthread :: Action n r -> Thread n r

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

Methods

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

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

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

Determine if a thread is blocked in a certain way.

Exceptions

data Handler n r

An exception handler.

Constructors

Exception e => Handler (e -> MaskingState -> Action n r)

propagate :: SomeException -> ThreadId -> Threads n r -> Maybe (Threads n r)

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

interruptible :: Thread n r -> Bool

Check if a thread can be interrupted by an exception.

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

Register a new exception handler.

uncatching :: ThreadId -> Threads n r -> Threads n r

Remove the most recent exception handler.

except :: (MaskingState -> Action n r) -> [Handler n r] -> ThreadId -> Threads n r -> Threads n r

Raise an exception in a thread.

mask :: MaskingState -> ThreadId -> Threads n r -> Threads n r

Set the masking state of a thread.

Manipulating threads

goto :: Action n r -> ThreadId -> Threads n r -> Threads n r

Replace the Action of a thread.

launch :: ThreadId -> ThreadId -> ((forall b. M n r b -> M n r b) -> Action n r) -> Threads n r -> Threads n r

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

launch' :: MaskingState -> ThreadId -> ((forall b. M n r b -> M n r b) -> Action n r) -> Threads n r -> Threads n r

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

block :: BlockedOn -> ThreadId -> Threads n r -> Threads n r

Block a thread.

wake :: BlockedOn -> Threads n r -> (Threads n r, [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 :: MonadConc n => ThreadId -> Threads n r -> n (Threads n r)

Turn a thread into a bound thread.

kill :: MonadConc n => ThreadId -> Threads n r -> n (Threads n r)

Kill a thread and remove it from the thread map.

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

runLiftedAct :: MonadConc n => ThreadId -> Threads n r -> n (Action n r) -> n (Action n r)

Run an action.

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