https://github.com/kassane/context

`boost.context` library using zig build
https://github.com/kassane/context

boost boost-libraries cpp-library zig-package

Last synced: about 2 months ago
JSON representation

`boost.context` library using zig build

• Host: GitHub
• URL: https://github.com/kassane/context
• Owner: kassane
• Fork: true (boostorg/context)
• Created: 2023-06-18T17:26:42.000Z (about 1 year ago)
• Default Branch: zig-pkg
• Last Pushed: 2024-06-26T13:09:25.000Z (3 months ago)
• Last Synced: 2024-06-26T16:07:16.640Z (3 months ago)
• Topics: boost, boost-libraries, cpp-library, zig-package
• Language: Assembly
• Homepage:
• Size: 7.87 MB
• Stars: 0
• Watchers: 0
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

• awesome-zig - context

README

        
boost.context

=============

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 execution_context 

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 fiber provides the means to suspend the current execution path and to transfer execution control, 

thereby permitting another fiber to run on the current thread. This state full transfer mechanism 

enables a fiber to suspend execution from within nested functions and, later, to resume from where it 

was suspended. While the execution path represented by a fiber 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 fibers requires only fewer than 

hundred CPU cycles because it does not involve system calls as it is done within a single thread.

boost.context requires C++11!