Editing Lightweight concurrency (section)

== Concurrency libraries ==

In order to support the construction of extensible user-level schedulers in GHC, special care has to be taken about blocking concurrency actions. When there is no default scheduler, the user-level scheduler must be made aware of the blocking action, and more interestingly, the blocking action of the user-level scheduler.

=== Motivation ===

The interaction between user-level schedulers and blocking actions is motivated through actions on MVars.The semantics of takeMVar is to block the calling thread if the MVar is empty, and eventually unblock and return the value when the MVar becomes full. Internally, when a thread blocks on an MVar, it switches
to the next runnable thread. This assumes that the takeMVar has knowledge about the scheduler. In particular, the current implementation of takeMVar knows how to perform the following:

* '''Block action''': blocking the current thread on a condition, and switching to another runnable thread.
* '''Unblock action''': placing the unblocked thread back into the scheduler data structure.

=== Proposal ===

The new, scheduler agnostic version of takeMVar (say takeMVarPrim), will have the type:

<haskell>
takeMVarPrim :: PTM () -> PTM () -> MVarPrim a -> IO a
</haskell>

where the first and second arguments are the block and unblock actions. If the blocking and unblocking actions are known, takeMVar with its usual type can be obtained simply by partial application:

<haskell>
takeMVar :: MVarPrim a -> IO a
takeMVar = takeMVarPrim blockAct unblockAct
</haskell>

Since the MVar implementation is independent of the schedulers, even threads from different schedulers can perform operations on the same MVar. The knowledge of schedulers is completely embedded in the block and unblock actions. Block and unblock actions can be obtained from [[Lightweight_concurrency#Up-call_handlers|up-call handlers]].