Execution control library (since C++26)

Die Execution Control-Bibliothek bietet ein Framework zur Verwaltung asynchroner Ausführung auf generischen Ausführungsressourcen.

Die Bibliothek zielt darauf ab, Vokabulartypen für asynchrone Operationen bereitzustellen und die Konstruktion von Aufgabenausführungsgraphen auf einfache, komponierbare Weise zu ermöglichen.

Bibliotheksweite Definitionen

• Sender : Eine Beschreibung asynchroner Arbeit, die zur Ausführung gesendet werden soll. Erzeugt einen Operationszustand (unten).

• Sender senden ihre Ergebnisse asynchron an Listener, die "Receiver" genannt werden (unten).
• Sender können mit generischen Algorithmen zu Task-Graphen zusammengesetzt werden.
• Sender-Fabriken und -Adapter sind generische Algorithmen, die gängige asynchrone Muster in Objekten erfassen, die das sender Konzept erfüllen.

• Receiver : Ein generalisierter Callback, der die asynchronen Ergebnisse verarbeitet oder "empfängt", die von einem Sender erzeugt werden.

• Empfänger verfügen über drei verschiedene "Kanäle", über die ein Sender Ergebnisse propagieren kann: Erfolg, Fehler und Abbruch, genannt "Value", "Error" und "Stopped".
• Empfänger bieten eine erweiterbare Ausführungsumgebung: einen Satz von Schlüssel/Wert-Paaren, den der Consumer zur Parametrisierung des asynchronen Vorgangs verwenden kann.

• Betriebszustand : Ein Objekt, das den für den asynchronen Vorgang benötigten Zustand enthält.

• Ein Sender und ein Empfänger werden verbunden, wenn sie an die std::execution::connect -Funktion übergeben werden.
• Das Ergebnis der Verbindung eines Senders und eines Empfängers ist ein Operationszustand.
• Arbeit wird erst zur Ausführung eingereiht, wenn " start " auf einem Operationszustand aufgerufen wird.
• Einmal gestartet, darf die Lebensdauer des Operationszustands nicht enden, bevor der asynchrone Vorgang abgeschlossen ist, und seine Adresse muss stabil sein.

• Scheduler : Ein leichtgewichtiger Handle für einen Ausführungskontext.

• Ein Ausführungskontext ist eine Quelle asynchroner Ausführung wie ein Thread-Pool oder ein GPU-Stream.
• Ein Scheduler ist eine Fabrik für einen Sender, der seinen Empfänger von einem Ausführungsthread abschließt, der dem Ausführungskontext gehört.

Bibliothekshilfsmittel

Konzepte

Scheduler

Sender

Empfänger

Betriebszustände

Hilfskomponenten

Ausführungskontexte

Ausführungsdomänen

Fortschrittsgarantie

Umgebungen

Abfragen

Abschlusssignaturen

Coroutinen-Hilfsfunktionen

Kernoperationen

Betriebszustand

Abschlussfunktionen

Diese Funktionen werden von Sendern aufgerufen, um den Abschluss der Arbeit ihren Empfängern mitzuteilen.

Sender-Algorithmen

Sender-Fabriken

Eine Sender-Factory ist eine Funktion, die einen Sender zurückgibt und deren Parameter Typen haben, für die das sender Konzept false ist.

Folgende sind Absender-Fabriken:

Pipeable Sender-Adapter

Sender-Adapter

Ein Sender-Adapter ist eine Funktion, die einen Sender zurückgibt, deren Parameter mindestens einen enthalten, dessen Typ das sender Konzept erfüllt, und bei der der zurückgegebene Sender ein übergeordneter Sender der Sender-Argumente der Adapterfunktion ist.

Folgende sind Sender-Adapter:

Sender-Verbraucher

Ein Sender-Consumer ist ein Algorithmus, der einen oder mehrere Sender als Parameter nimmt und der keinen Sender zurückgibt.

Beispiel

#include <cstdio>
#include <execution>
#include <string>
#include <thread>
#include <utility>
using namespace std::literals;
int main()
{
    std::execution::run_loop loop;
    std::jthread worker([&](std::stop_token st)
    {
        std::stop_callback cb{st, [&]{ loop.finish(); }};
        loop.run();
    });
    std::execution::sender auto hello = std::execution::just("hello world"s);
    std::execution::sender auto print
        = std::move(hello)
        | std::execution::then([](std::string msg)
        {
            return std::puts(msg.c_str());
        });
    std::execution::scheduler auto io_thread = loop.get_scheduler();
    std::execution::sender auto work = std::execution::on(io_thread, std::move(print));
    auto [result] = std::this_thread::sync_wait(std::move(work)).value();
    return result;
}

hello world

Siehe auch