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.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
