Start a new thread.

Get the ThreadId of the current thread.

Get the number of Haskell threads that can run simultaneously.

Set the number of Haskell threads that can run simultaneously.

Yield the current thread.

Create a new MVar.

Put into a MVar, possibly waking up some threads.

Get blocked on a put.

Try to put into a MVar, possibly waking up some threads.

Read from a MVar.

Try to read from a MVar.

Get blocked on a read.

Take from a MVar, possibly waking up some threads.

Get blocked on a take.

Try to take from a MVar, possibly waking up some threads.

Create a new CRef.

Read from a CRef.

Read from a CRef for a future compare-and-swap.

Modify a CRef.

Modify a CRef using a compare-and-swap.

Write to a CRef without synchronising.

Attempt to to a CRef using a compare-and-swap, synchronising it.

Commit the last write to the given CRef by the given thread, so that all threads can see the updated value.

An STM transaction was executed, possibly waking up some threads.

Got blocked in an STM transaction.

Register a new exception handler

Pop the innermost exception handler from the stack.

Throw an exception.

Throw an exception to a thread.

Get blocked on a throwTo.

Killed by an uncaught exception.

Set the masking state. If True, this is being used to set the masking state to the original state in the argument passed to a masked function.

Return to an earlier masking state. If True, this is being used to return to the state of the masked block in the argument passed to a masked function.

Lift an IO action. Note that this can only happen with ConcIO.

A return or pure action was executed.

Cease execution and terminate.

Start executing an action with subconcurrency.

Stop executing an action with subconcurrency.

Will start a new thread.

Will get the ThreadId.

Will get the number of Haskell threads that can run simultaneously.

Will set the number of Haskell threads that can run simultaneously.

Will yield the current thread.

Will create a new MVar.

Will put into a MVar, possibly waking up some threads.

Will try to put into a MVar, possibly waking up some threads.

Will read from a MVar.

Will try to read from a MVar.

Will take from a MVar, possibly waking up some threads.

Will try to take from a MVar, possibly waking up some threads.

Will create a new CRef.

Will read from a CRef.

Will read from a CRef for a future compare-and-swap.

Will modify a CRef.

Will modify a CRef using a compare-and-swap.

Will write to a CRef without synchronising.

Will attempt to to a CRef using a compare-and-swap, synchronising it.

Will commit the last write by the given thread to the CRef.

Will execute an STM transaction, possibly waking up some threads.

Will register a new exception handler

Will pop the innermost exception handler from the stack.

Will throw an exception.

Will throw an exception to a thread.

Will set the masking state. If True, this is being used to set the masking state to the original state in the argument passed to a masked function.

Will return to an earlier masking state. If True, this is being used to return to the state of the masked block in the argument passed to a masked function.

Will lift an IO action. Note that this can only happen with ConcIO.

Will execute a return or pure action.

Will cease execution and terminate.

Will execute an action with subconcurrency.

Will stop executing an extion with subconcurrency.

A readCRef or a readForCAS.

A writeCRef.

Some other action which doesn't require cross-thread communication.

A commit.

A casCRef

A modifyCRefCAS

An atomicModifyCRef.

A readMVar or takeMVar (or try/blocked variants).

A putMVar (or try/blocked variant).

Some other action which does require cross-thread communication.

Create a new TVar

Read from a TVar.

Write to a TVar.

Abort and discard effects.

Execute a transaction until it succeeds (STMStop) or aborts (STMRetry) and, if it aborts, execute the other transaction.

Throw an exception, abort, and discard effects.

Execute a transaction until it succeeds (STMStop) or aborts (STMThrow). If the exception is of the appropriate type, it is handled and execution continues; otherwise aborts, propagating the exception upwards.

Terminate successfully and commit effects.

Start a new thread, because the last was blocked (or it's the start of computation).

Continue running the last thread for another step.

Pre-empt the running thread, and switch to another.

Will be raised if the scheduler does something bad. This should never arise unless you write your own, faulty, scheduler! If it does, please file a bug report.

The scheduler chose to abort execution. This will be produced if, for example, all possible decisions exceed the specified bounds (there have been too many pre-emptions, the computation has executed for too long, or there have been too many yields).

The computation became blocked indefinitely on MVars.

The computation became blocked indefinitely on TVars.

An uncaught exception bubbled to the top of the computation.

Calls to subconcurrency were nested, or attempted when multiple threads existed.

The most intuitive model: a program behaves as a simple interleaving of the actions in different threads. When a CRef is written to, that write is immediately visible to all threads.

Each thread has a write buffer. A thread sees its writes immediately, but other threads will only see writes when they are committed, which may happen later. Writes are committed in the same order that they are created.

Each CRef has a write buffer. A thread sees its writes immediately, but other threads will only see writes when they are committed, which may happen later. Writes to different CRefs are not necessarily committed in the same order that they are created.