lewissbaker/cppcoro
Cppcoro
cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop.
The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution.
Its capability surface covers asynchronous control flow, including task definition, result transformation, and concurrent result aggregation. It provides execution context management to control where coroutines start and resume, alongside non-blocking file and network I/O support.
The project includes configuration utilities for managing build toolchains, compiler paths, and installation prefixes.
Features
- Coroutines - Provides a comprehensive library of coroutine primitives for building asynchronous, non-blocking C++ applications.
- C++ Coroutine Primitives - Provides a comprehensive framework based on C++20 specifications for low-level awaitables and lazy execution.
- Asynchronous Sequence Generators - Produces sequences of values lazily where each individual element is generated using asynchronous operations.
- Async Coordination Primitives - Ships a concurrency toolkit with async mutexes and latches to coordinate multi-threaded execution.
- Async Concurrency Toolkits - Provides a collection of async mutexes, latches, and shared tasks to coordinate multi-threaded execution.
- Asynchronous I/O Libraries - Functions as a non-blocking I/O framework for managing network and file operations via an event loop.
- Async Generator Libraries - Provides a specialized toolkit for producing lazy sequences of values both synchronously and asynchronously.
- Async Generators - Implements asynchronous generators for producing lazy sequences of values using C++ coroutines.
- Coroutine Scheduler Controls - Allows assigning specific schedulers to control where coroutines start and resume after asynchronous operations.
- Lazy Sequences - Provides generators that produce values on demand without blocking the calling thread.
- Execution Context Controls - Enables specifying the exact execution context where a paused coroutine should resume its work.
- Synchronization Primitives - Implements async mutexes and latches that suspend coroutines without blocking physical execution threads.
- Lazy Task Definitions - Defines lazy computations that remain paused until they are explicitly awaited for execution.
- I/O Event Dispatchers - Monitors asynchronous I/O events via an event loop to trigger the resumption of suspended coroutines.
- Asynchronous Task Execution - Executes lazy computations that return a result or throw an exception upon being awaited.
- Event-Driven I/O - Uses an event-loop based dispatch system to resume suspended coroutines upon I/O completion.
- Thread Pool Context Propagators - Tracks execution environments to ensure coroutines resume on the appropriate scheduler or thread pool.
- Work-Stealing Thread Pools - Implements a work-stealing thread pool to balance asynchronous task distribution across multiple CPU cores.
- Async Latches - Implements asynchronous latches that suspend operations until a counter reaches zero.
- Asynchronous Socket Libraries - Provides asynchronous TCP and UDP socket implementations for non-blocking network communication.
- Work-Stealing Schedulers - Employs a work-stealing scheduler to dynamically balance computational tasks across hardware threads.
- All-Completion Synchronization - Creates synchronization points that resolve only after all provided asynchronous tasks have finished.
- Mutual Exclusion Locks - Provides asynchronous mutual exclusion locks that suspend the calling coroutine instead of blocking the thread.
- Task State Management - Manages the state and results of asynchronous computations through promise objects to coordinate resumption.
- Synchronous Generators - The project produces a sequence of values lazily and synchronously using a generator that yields values without suspending.
- Asynchronous Event Notification Libraries - Provides event primitives to signal the resumption of suspended asynchronous operations.
- Awaitable Transformations - Applies functions to asynchronous results to produce new tasks with transformed values.
- Asynchronous File I/O - Provides non-blocking interfaces for performing read and write operations on the file system.
- Asynchronous Operation Cancellation - Provides token-based polling and callback mechanisms to signal the premature termination of asynchronous operations.
- Shared Asynchronous Results - Allows multiple callers to await the same asynchronous result and resume all of them upon completion.
- Task Result Aggregation - Executes multiple asynchronous operations simultaneously and aggregates their results into a single collection.
- Asynchronous Network Programming - Provides non-blocking TCP and UDP socket operations using event-driven I/O for high-concurrency network programming.
