[C++] std::execution & Senders/Receivers: Foundations of High-Performance Concurrency

Asynchronous and parallel programming in C++ has historically been burdened with fragmented primitives. std::thread, std::future, and std::promise introduced mandatory heap allocations, lacked composability, forced thread blocking, and lacked standardized cancellation mechanisms.

Officially standardized in C++26, std::execution (P2300: Senders/Receivers model) completely unifies this ecosystem, providing Zero-Allocation Structured Concurrency natively in the ISO C++ standard library.

This article explores the core triad of std::execution—Schedulers, Senders, and Receivers—and examines production-grade code architectures for building high-throughput pipelines in HTS and high-performance server domains.

1. The Limitations of Legacy C++ Concurrency & The Genesis of std::execution

Legacy C++ concurrency primitives struggled to satisfy modern multicore, ultra-low-latency requirements:

• The Bottleneck of std::future: Shared state synchronization forces dynamic heap allocations, while the absence of continuation chaining (.then()) requires threads to block on get().
• The Flaw of std::async: The implicit blocking destructor of returned futures causes unpredictable latency spikes and thread stalling.
• Lack of Cancellation: No standardized mechanism existed to abort inflight asynchronous operations gracefully upon timeouts or disconnects.

std::execution solves this by completely decoupling "what work to do" (Senders) from "where and how to run it" (Schedulers), enabling compile-time graph composition with zero heap overhead.

▲ Asynchronous Model Evolution: std::future vs C++26 std::execution

2. The Three Core Abstractions: Schedulers, Senders, Receivers

The std::execution model is built upon three foundational primitives:

2.1 Schedulers

• Role: Lightweight handles representing execution contexts (thread pools, GPU streams, event loops, I/O threads).
• Operation: Calling std::execution::schedule(sch) yields a Sender ready to initiate work on that target context.

2.2 Senders

• Role: Lazy descriptions (blueprints) of asynchronous computations. Senders do not execute immediately; they describe what will happen once connected.
• Three Completion Signals:
  1. set_value(args...): Successful completion delivering results
  2. set_error(e): Failure completion forwarding errors/exceptions
  3. set_stopped(): Explicit cancellation signal

2.3 Receivers

• Role: Callback sinks that consume completion signals emitted by Senders.
• Algorithms internally connect Senders and Receivers into an operation_state with zero dynamic memory allocation.

▲ Signal lifecycle across Schedulers, Senders, and Receivers

3. Constructing High-Performance Asynchronous Pipelines

std::execution leverages the pipeline operator (|) to compose complex async workflows declaratively:

3.1 Foundational Pipeline Example: Thread Transfers and Chaining

Receiving raw data on an I/O thread pool, transferring execution to a computation pool, and synchronizing results:

#include <execution>
#include <iostream>

namespace ex = std::execution;

void BasicPipelineExample(ex::scheduler auto io_sched, ex::scheduler auto cpu_sched) {
    // Declarative asynchronous pipeline (Lazy Sender)
    auto work = ex::schedule(io_sched)
        // 1. Read data on I/O scheduler
        | ex::then([]() {
            std::cout << "[I/O Thread] Raw data received\n";
            return 42; // Returns raw payload
        })
        // 2. Transfer execution context to CPU worker pool
        | ex::transfer(cpu_sched)
        // 3. Execute heavy processing on CPU worker thread
        | ex::then([](int val) {
            std::cout << "[CPU Thread] Processing heavy computation\n";
            return val * 100;
        })
        // 4. Attach error handler
        | ex::upon_error([](std::exception_ptr e) {
            std::cerr << "Error occurred during execution\n";
            return 0;
        });

    // 5. Connect, start, and synchronously await results
    auto result = ex::sync_wait(std::move(work));
    if (result) {
        auto [finalValue] = *result;
        std::cout << "Final Result: " << finalValue << "\n";
    }
}

4. Production Use Case: Real-Time HTS Market Data Pipeline

Structuring a real-time trading market data pipeline from network tick ingestion to quantitative calculation and UI dispatch:

#include <execution>
#include <tuple>
#include <vector>

namespace ex = std::execution;

struct MarketTick {
    uint32_t symbolId;
    double price;
    uint64_t volume;
};

struct AnalyzedIndicator {
    uint32_t symbolId;
    double movingAverage;
    bool isBreakout;
};

// Generates an end-to-end market data pipeline
auto CreateMarketDataPipeline(ex::scheduler auto netSched, 
                             ex::scheduler auto workerPool, 
                             ex::scheduler auto uiSched,
                             uint32_t targetSymbol) 
{
    return ex::schedule(netSched)
        // 1. Ingest market packet on network thread
        | ex::then([targetSymbol]() -> MarketTick {
            return NetworkDriver::FetchTick(targetSymbol);
        })
        // 2. Transfer to high-performance thread pool for quantitative analytics
        | ex::transfer(workerPool)
        | ex::then([](const MarketTick& tick) -> AnalyzedIndicator {
            double ma20 = IndicatorEngine::CalculateMA(tick.symbolId, tick.price);
            bool breakout = tick.price > ma20 * 1.05;
            return AnalyzedIndicator{ tick.symbolId, ma20, breakout };
        })
        // 3. Safely transition to UI thread for rendering
        | ex::transfer(uiSched)
        | ex::then([](const AnalyzedIndicator& indicator) {
            if (indicator.isBreakout) {
                UIComponent::HighlightSignal(indicator.symbolId);
            }
            UIComponent::UpdatePriceView(indicator.symbolId, indicator.movingAverage);
        });
}

4.1 Parallel Ingestion with when_all

auto multiFetch = ex::when_all(
    CreateMarketDataPipeline(netSched, workerPool, uiSched, 005930), // Stock A
    CreateMarketDataPipeline(netSched, workerPool, uiSched, 000660)  // Stock B
)
| ex::then([](auto res1, auto res2) {
    std::cout << "Both tickers processed in parallel without lock contention!\n";
});

▲ Real-time multi-context pipeline flow from Network to UI

5. Architectural Comparison with Legacy Models

6. Conclusion: A Unified Standard for C++ Asynchronous Systems

std::execution (P2300) delivers the long-awaited standardized asynchronous foundation for C++:

Developers can immediately adopt this model via NVIDIA's open-source `stdexec` library across C++20 and C++23 codebases, laying a future-proof foundation for next-generation trading and distributed systems.

7. Frequently Asked Questions (FAQ)