Boost.Context is a foundational library that
provides a sort of cooperative multitasking on a single thread. By providing
an abstraction of the current execution state in the current thread, including
the stack (with local variables) and stack pointer, all registers and CPU flags,
and the instruction pointer, a fcontext_t instance represents
a specific point in the application's execution path. This is useful for building
higher-level abstractions, like coroutines, cooperative
threads (userland threads) or an equivalent to C#
keyword yield in C++.

A fcontext_t provides the means to suspend the current
execution path and to transfer execution control, thereby permitting another
fcontext_t to run on the current thread. This state full
transfer mechanism enables a fcontext_t to suspend execution
from within nested functions and, later, to resume from where it was suspended.
While the execution path represented by a fcontext_t only
runs on a single thread, it can be migrated to another thread at any given
time.

A context switch between threads requires system calls (involving the OS kernel),
which can cost more than thousand CPU cycles on x86 CPUs. By contrast, transferring
control among them requires only fewer than hundred CPU cycles because it does
not involve system calls as it is done within a single thread.

In order to use the classes and functions described here, you can either include
the specific headers specified by the descriptions of each class or function,
or include the master library header:

#include<boost/context/all.hpp>

which includes all the other headers in turn.

All functions and classes are contained in the namespace boost::context.