Difference between revisions of "cpp/execution"

Revision as of 01:38, 26 January 2024

Note This is a planned extension to the <execution> (C++17)

Draft The functionality described on this page is a draft, based on the latest revision of P2300, targeting C++26.

The Execution library provides 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. Executed by calling “start”
• Scheduler - Execution context on which operation can run (CPU, thread pool, GPU threads, Event loop, etc.)

Library utilities

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.

Sender adaptors

A sender adaptor takes a sender and returns a sender.

Adaptors for single-shot and multi-shot senders

Adaptors for multi-shot senders

Example

#include <iostream>
#include <stdexec/execution.hpp>
#include <thread>
 
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;
    });
 
    const auto [result] =
        stdexec::sync_wait(stdexec::on(loop.get_scheduler(), std::move(work))).value();
    loop.finish();
    worker.join();
    return result;
}

hello world