$ show google/marl
Marl is a high-performance, hybrid thread/fiber task scheduler library written in C++11. It provides a flexible and fluent API for scheduling asynchronous tasks across a configurable number of worker threads, while using fibers (cooperative lightweight threads) to allow tasks to block and yield without stalling hardware threads. The library includes a rich set of synchronization primitives (Event, WaitGroup, Ticket, ConditionVariable, mutex, and DAG for declarative task graphs). It emphasizes safe capture-by-value semantics for primitives to avoid dangling references. The implementation is platform-agnostic with hand-optimized assembly fiber context switching for x86/x64, ARM, RISC-V, LoongArch, MIPS64, and PowerPC64, plus Windows fibers and Emscripten support. The project includes extensive unit tests and benchmarks, a pluggable memory allocator interface, and a tracked allocator for debugging. It is designed as a library to be embedded into larger C++ applications that require fine-grained concurrency control. The codebase demonstrates strong engineering craftsmanship: clean separation of concerns, excellent use of C++ features, Thread Safety Analysis annotations, and thorough testing. Key reusable components include the custom containers (small-buffer optimized vector and efficient list), the pool abstraction (bounded and unbounded), and the flexible allocator framework.
The LLM identified 3 files worth highlighting for reuse:
Provides marl::containers::vector and marl::containers::list with small-buffer optimization and allocation chain, reducing heap allocations for small sizes. The vector keeps a fixed number of elements inline and only allocates dynamically when capacity is exceeded. The list pre-allocates blocks of entries and recycles them, avoiding repeated allocation overhead. These containers are self-contained, depend only on the Allocator interface, and can be extracted for use in other projects requiring efficient containers.
Defines the marl::Allocator abstract interface, a pluggable memory allocator used throughout marl. It includes convenience methods (create, destroy, make_unique, make_shared) that respect alignment and usage tracking. The companion TrackedAllocator wraps any allocator and collects per-usage allocation statistics, invaluable for debugging and performance analysis. This component is cleanly abstracted and can be reused as a foundation for custom memory management in other C++ projects.
Implements BoundedPool and UnboundedPool, generic object pooling templates. BoundedPool has a fixed maximum capacity and blocks when empty; UnboundedPool auto-allocates new items. Both support PoolPolicy (Reconstruct vs Preserve) to control construction/destruction on borrow/return. The pool provides a Loan smart pointer with reference counting that automatically returns the item to the pool when the last reference drops. This pattern solves the recurring need for efficient object reuse in concurrent systems and is easily portable to other projects.