Editing Lightweight concurrency (section)

=== Bound threads ===

Bound threads [http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Concurrent.html#g:9] are ''bound'' to operating system threads (tasks), and only the task to which the haskell thread is bound to can run it. In the vanilla implementation, bound threads are created using <hask>forkOS</hask> primitive, which creates a new task to run this bound thread. 

A bound thread and its bound task have the invariant that if the bound thread is running, it is running on its bound task, and when the bound thread is blocked, its bound is suspended. When a bound thread is resumed, RTS checks if the current task is its bound task. If not, current task is suspended, and the current capability is passed to the bound task, which resumes the bound thread.
Thus, bound threads are handled transparently from the programmer's point of view, and the programmer never sees the tasks.

'''LWC implementation'''

We would like to have the same interface in the LWC implementation. Bound threads can be created with the new substrate primitive:

<haskell>
newBoundSCont :: IO () -> IO SCont
</haskell>

which has the same type signature as <hask>newSCont</hask>. But unlike <hask>newSCont</hask>, a new OS thread (a task), is created in a suspended state and bound to the new thread. During a user-level context switch, the target thread is assigned as the current capability's thread and the control is returned to RTS scheduler loop. The RTS scheduler loop, as it does for the vanilla implementation, takes care of passing capabilities between tasks, creating worker tasks, etc., if the control switches to or from a bound thread.