Concurrency on Pi Stack

Self-Hosted Coroutine Libraries: libaco vs greenlet vs libco vs boost::context — Asymmetric Coroutines for High-Concurrency C/C++ Systems

Sun, 21 Jun 2026 00:00:00 +0000

Why Coroutines Matter for High-Concurrency Systems

Traditional multi-threaded programming with one OS thread per task hits a scalability wall: each thread consumes 8-16 MB of stack space and incurs kernel scheduling overhead. At 10,000 concurrent connections, thread stacks alone consume 80-160 MB of memory. At 100,000 connections, the overhead becomes prohibitive. Coroutines solve this by multiplexing thousands of logical tasks onto a small number of OS threads — each coroutine uses only kilobytes of state rather than megabytes.

Actor Model Frameworks for Distributed Systems: Orleans vs Akka.NET vs ProtoActor vs CAF

Sat, 20 Jun 2026 00:00:00 +0000

What Is the Actor Model?

The Actor Model is a mathematical model for concurrent computation that treats “actors” as the universal primitives of computation. Each actor can make local decisions, create more actors, send messages, and determine how to respond to the next message received. The model naturally handles concurrency without locks, making it ideal for building distributed systems.

Self-Hosted Lock-Free Data Structure Libraries: concurrentqueue vs ReaderWriterQueue vs Boost.Lockfree (2026)

Sat, 20 Jun 2026 00:00:00 +0000

Introduction

When building self-hosted services that need to process millions of events per second, traditional locking primitives like std::mutex become the bottleneck. A single contended mutex can reduce throughput by 80-90% compared to a well-designed lock-free alternative. For C++ developers building trading engines, game servers, network proxies, and real-time data processors, lock-free data structures are not an optimization — they’re a requirement.

Self-Hosted Lock-Free Concurrent Data Structures: crossbeam vs Disruptor vs Folly vs concurrency-kit

Fri, 19 Jun 2026 00:00:00 +0000

The Lock-Free Programming Paradigm

Traditional concurrent programming relies on mutexes and locks to protect shared data. When one thread holds a lock, all other threads must wait — leading to contention, priority inversion, and in the worst case, deadlocks. Lock-free data structures eliminate these problems by using atomic CPU instructions (compare-and-swap, fetch-and-add) to allow multiple threads to operate on shared data simultaneously without ever blocking each other.

Self-Hosted Object Pool Libraries in Go: ants vs pond vs bytebufferpool vs conc

Fri, 19 Jun 2026 00:00:00 +0000

Introduction

Go’s goroutines are lightweight, but spawning thousands of them without bounds can still exhaust memory and degrade performance. Object pool libraries solve this by pre-allocating resources and reusing them — reducing GC pressure, bounding concurrency, and improving throughput in self-hosted Go services.