Tencent/libco
Libco
libco is a C++ coroutine library and user-space task orchestrator designed for cooperative multitasking and high-concurrency execution. It functions as a high-concurrency network framework and a synchronous-to-asynchronous wrapper that allows blocking system calls and socket functions to run asynchronously without modifying existing business logic.
The project utilizes a specialized stack-copying context switching model to support millions of simultaneous TCP connections on a single machine. It includes a high-performance time wheel scheduler for managing asynchronous background jobs and delayed operations with constant-time complexity.
The library provides capabilities for fine-grained task switching and concurrent state management, using private variables and signals for communication between coroutines. It integrates non-blocking I/O and system-call interception to manage the lifecycle of lightweight threads without relying on kernel-level preemption.
Features
- Cooperative Schedulers - Implements a cooperative scheduler where tasks voluntarily yield control to manage high-concurrency execution flow.
- User-Space Concurrency - Orchestrates the creation, resumption, and yielding of concurrent tasks in user-space to avoid blocking the main thread.
- High-Concurrency Networking - Handles millions of simultaneous TCP connections on a single machine using lightweight coroutines.
- Stack-Copying Context Switches - Saves and restores CPU registers and memory segments by copying the coroutine stack to enable high-density concurrency.
- Synchronous-to-Asynchronous Wrappers - Provides a mechanism to intercept system calls and socket functions, allowing synchronous business logic to execute asynchronously.
- System-Call Interception - Wraps blocking I/O and socket functions to yield execution back to the scheduler until resources become available.
- Concurrent Thread Execution - Enables pausing and resuming multiple functions to handle high volumes of concurrent processing.
- Coroutine Libraries - Provides a C++ library for managing cooperative multitasking and high-concurrency execution through lightweight user-space threads.
- Coroutines - Provides a minimal interface for creating, resuming, and yielding execution between coroutines for fine-grained task switching.
- Non-blocking I/O - Integrates non-blocking I/O to handle millions of concurrent network connections without blocking the main execution thread.
- Time Wheel Schedulers - Provides a high-performance time wheel mechanism for executing asynchronous background jobs and delayed operations.
- Time Wheel Schedulers - Uses a circular buffer to track and trigger timed events with constant-time complexity for high-performance task management.
- Coroutine Channels - Implements a system for sharing private variables and signals to coordinate state and communication between coroutines.
- Fine-Grained Task Switching - Controls the execution lifecycle of coroutines to switch between functions without blocking the main thread.
- High-Performance Task Schedulers - Manages background jobs and timed operations using a high-performance time wheel to minimize overhead.
- Concurrent State Coordination - Coordinates communication and shared state between concurrent tasks using signals and private variables.
- Coroutine Private Variables - Allocates dedicated memory regions for each coroutine to maintain local state and variables across execution suspensions.
- Asynchronous Event Loops - Coroutine-based library for high-concurrency I/O.
