Execution library

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Experimental

Technical Specification

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals TS v2)

Library fundamentals 3 (library fundamentals TS v3)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Extensions for concurrency 2 (concurrency TS v2)

Concepts (concepts TS)

Ranges (ranges TS)

Reflection (reflection TS)

Mathematical special functions (special functions TR)

Experimental Non-TS

Pattern Matching

Linear Algebra

std::execution

Contracts

2D Graphics

 

Execution Library

Senders

Sender factories

Sender adaptors

Adaptors for single-shot and multi-shot senders

Adaptors for multi-shot senders

Sender consumers

Eager execution

 

The Execution library suggests a framework for managing asynchronous execution on generic execution resources, targeting the standard C++ library.

The library aims to provide vocabulary types for async operations and to allow the construction of tasks execution graphs in a simple, composable way.

Library-wide definitions

• Sender - Contains data and/or work to be sent for execution.

• Senders can be chained to build execution pipes (translated into a task graph).
• Different types of senders can be produced by senders factories/adaptors.

• Receiver/Sender Consumer - Closure of execution pipe, consume sender(s) and returns an Operation State.

• Receiver contains environment, which holds data on the execution context
• By default (if not provided) the environment is the default env.

• Operation State - Object which holds: data + work + execution context. Execution by calling “state”
• Scheduler - Execution context on which operation can run (CPU, thread pool, GPU threads, Event loop, etc.)

Senders

Sender Factories

A sender factory takes a non-sender (function/data) and returns a sender.

A sender with no completion schedulers is an “open-ended” operation, that can be used in the pipe. All the following senders are created without a completion scheduler.

Template:cpp/execution/dsc read

Defined in header <execution>
Defined in namespace std::execution
execution::schedule (C++26)	prepares a task graph for execution on a given scheduler (customization point object)
execution::just (C++26)	Accepts a variadic number of arguments and returns a sender that, when connected and started, completes synchronously by passing the arguments to the receiver's value completion function (customization point object)
execution::just_error (C++26)	Accepts a single argument and returns a sender that, when connected and started, completes synchronously by passing the argument to the receiver's error completion function (customization point object)
execution::just_stopped (C++26)	creates a sender that completes immediately by calling its receiver's set_stopped (customization point object)

Example

Note: the example is using stdexec (available on godbolt), which is an experimental reference implementation for "std::execution".

Run this code

#include <thread>
#include <iostream>
#include <stdexec/execution.hpp>
 
using namespace std::literals;
stdexec::run_loop loop;
std::thread worker([]{ loop.run(); });
 
 
int main() 
{
   auto hello = stdexec::just("hello world"s);
   auto work = hello | stdexec::then( [](auto msg) {
      std::cout << msg << '\n';
      return 0;
   });
 
   auto [result] = stdexec::sync_wait(stdexec::on(loop.get_scheduler(), std::move(work))).value();
   loop.finish();
   worker.join();
   return result;
}