How does TooManyCooks compare to Boost.Asio for concurrency?

TooManyCooks integrates with Asio for I/O but focuses on coroutine-based task scheduling with a high-performance thread pool, whereas Boost.Asio offers a broader event-driven model. The tmc-asio module bridges them for seamless use in network or file operations.

How to set up TooManyCooks in a CMake project?

Since it's header-only, add the include directory to your CMake target's include paths. For reduced compilation times, use the standalone compilation file as shown in the examples repository, especially for older versions.

Does TooManyCooks support error handling in coroutines?

Yes, it supports standard C++ exception handling in coroutines, with tasks able to throw and catch exceptions, and proper propagation through the task graph as per the API design.

What are the performance benchmarks for TooManyCooks on ARM?

The README notes testing on ARM devices like Apple M2 and Rockchip RK3588S, and benchmarks in the linked repository show optimized performance for AArch64 architectures, making it suitable for cross-platform use.

How to migrate from std::async to TooManyCooks?

Start by replacing std::async calls with tmc::post_waitable for synchronous APIs returning std::future, then gradually adopt coroutines for better parallelism, as the library provides a clear migration path for legacy code.

Is TooManyCooks suitable for real-time systems?

While it offers low-latency scheduling and priority levels, it's not designed for hard real-time constraints; users should evaluate based on specific needs, as the lock-free design helps but doesn't guarantee real-time performance.

Open-Awesome

TooManyCooks

BSL-1.0C++v1.6.1

A high-performance C++20 concurrency framework with lock-free work-stealing thread pools, Asio integration, and simple coroutine syntax.

GitHub

265 stars9 forks0 contributors

What is TooManyCooks?

TooManyCooks is a C++20 concurrency framework that provides a high-performance runtime for coroutines with lock-free work-stealing thread pools. It solves the need for efficient parallel execution in modern C++ applications while offering a simple syntax and extensive feature set.

Target Audience

C++ developers building performance-critical applications requiring advanced concurrency, parallel processing, or asynchronous I/O operations.

Value Proposition

Developers choose TooManyCooks for its benchmark-leading performance, clean API, and comprehensive feature set including Asio integration, hardware-aware thread configuration, and support for both coroutines and traditional functors.

Overview

C++20 concurrency framework with no compromises. Excellent performance, powerful features, and simple syntax.

Use Cases

Best For

Implementing high-performance parallel algorithms with C++20 coroutines
Building asynchronous network servers with integrated I/O support
Migrating legacy C++ applications to modern coroutine-based concurrency
Developing CPU-intensive applications requiring lock-free work-stealing schedulers
Creating cross-platform concurrency solutions for x86 and AArch64 architectures
Integrating third-party executors or event loops into existing C++ codebases

Not Ideal For

Projects targeting Windows with MSVC compiler due to unsupported critical bugs
Environments using older C++ compilers (GCC <14 or Clang <17)
Simple applications where coroutine overhead outweighs benefits
Teams needing vendor-backed support or commercial licensing options

Pros & Cons

Pros

Blazing Fast Performance

Features a lock-free, work-stealing thread pool optimized for speed, with benchmarks linked in the README demonstrating top-tier performance.

Hardware-Aware Scheduling

Leverages hwloc for intelligent thread configuration across CPU architectures, as noted in the README, improving resource utilization on diverse hardware.

Seamless Asio Integration

Provides network I/O, file I/O, and timer support via tmc-asio, simplifying asynchronous operations with existing Asio-based systems.

Flexible API Design

Supports both coroutines and regular functors, with traits-based extensibility for third-party awaitables and executors, enabling easy integration.

Cons

MSVC Incompatibility

Does not support MSVC due to a critical compiler bug causing crashes in Release builds, severely limiting Windows development options.

Stringent Compiler Requirements

Requires Clang 17+ or GCC 14+, which may not be available in all development or production environments, restricting adoption.

Setup Complexity for Stable Versions

Versions prior to v1.5 require creating a standalone compilation file, adding an extra step to the build process compared to simpler header-only libraries.

Frequently Asked Questions

Related Projects

concurrentqueue

A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

Stars12,416

Forks1,927

Last commit13 days ago

Taskflow

A General-purpose Task-parallel Programming System in C++

Stars12,079

Forks1,397

Last commit9 days ago

ThreadPool

A simple C++11 Thread Pool implementation

Stars8,769

Forks2,339

Last commit2 years ago

NCCL

Optimized primitives for collective multi-GPU communication

Stars4,904

Forks1,352

Last commit1 day ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub