Tencent/libco

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