Namensräume
Varianten
Aktionen

Bibliothek für Ausführungssteuerung (seit C++26)

Von cppreference.com
< cpp
 
C++
 
Bibliothek für Ausführungssteuerung
Konzepte der Ausführung
Komponenten der Ausführung
Ausführungskontexte
Ausführungsdomänen
Forward-Progress-Garantie
Umgebungen
Abfragen
Abschluss-Signaturen
  
Sender-Adaptor-Closures
Coroutine-Hilfsmittel
 

Die Bibliothek für Ausführungssteuerung bietet ein Framework zur Verwaltung der asynchronen Ausführung auf generischen Ausführungsressourcen.

Die Bibliothek zielt darauf ab, Vokabulartypen für asynchrone Operationen bereitzustellen und den Aufbau von Ausführungsaufgabengraphen auf einfache, komponierbare Weise zu ermöglichen.

Inhalt

[bearbeiten] Bibliotheksweite Definitionen

  • Sender: Eine Beschreibung von asynchroner Arbeit, die zur Ausführung gesendet wird. Erzeugt einen Operationszustand (unten).
  • Sender „senden“ ihre Ergebnisse asynchron an Zuhörer, die als „Empfänger“ (unten) bezeichnet werden.
  • Sender können mithilfe generischer Algorithmen zu Aufgabengraphen komponiert werden.
  • Sender-Fabriken und -Adaptoren sind generische Algorithmen, die gängige asynchrone Muster in Objekten erfassen, die dem sender-Konzept entsprechen.
  • Empfänger: Ein verallgemeinerter Callback, der die von einem Sender erzeugten asynchronen Ergebnisse verbraucht oder „empfängt“.
  • Empfänger verfügen über drei verschiedene „Kanäle“, über die ein Sender Ergebnisse propagieren kann: Erfolg, Fehler und Abbruch, bekannt als „Wert“, „Fehler“ und „gestoppt“.
  • Empfänger stellen eine erweiterbare Ausführungsumgebung bereit: eine Sammlung von Schlüssel/Wert-Paaren, die der Konsument zur Parametrisierung der asynchronen Operation verwenden kann.
  • Operationszustand: Ein Objekt, das den für die asynchrone Operation benötigten Zustand enthält.
  • Ein Sender und ein Empfänger werden verbunden, wenn sie an die Funktion std::execution::connect übergeben werden.
  • Das Ergebnis der Verbindung eines Senders und eines Empfängers ist ein Operationszustand.
  • Arbeit wird erst zur Ausführung eingereiht, wenn auf einem Operationszustand „start“ aufgerufen wird.
  • Sobald die Ausführung gestartet wurde, darf die Lebensdauer des Operationszustands nicht enden, bevor die asynchrone Operation abgeschlossen ist, und seine Adresse muss stabil sein.
  • Scheduler: Ein leichtgewichtiger Zeiger auf einen Ausführungskontext.
  • Ein Ausführungskontext ist eine Quelle für asynchrone Ausführung, z. B. ein Thread-Pool oder ein GPU-Stream.
  • Ein Scheduler ist eine Fabrik für einen Sender, der seinen Empfänger von einem Ausführungsfaden des Ausführungskontexts abschließt.

[bearbeiten] Bibliotheks-Hilfsmittel

[bearbeiten] Konzepte

[bearbeiten] Scheduler

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 spezifiziert, dass ein Typ ein Scheduler ist
(Konzept) [bearbeiten]

[bearbeiten] Sender

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 spezifiziert, dass ein Typ ein Sender ist
(Konzept) [bearbeiten]
(C++26)
 spezifiziert einen Sender, der asynchrone Operationen für gegebene assoziierte Umgebungs-Typen erstellen kann
(Konzept) [bearbeiten]
(C++26)
 spezifiziert einen Sender, der sich mit einem bestimmten Empfängertyp verbinden kann
(Konzept) [bearbeiten]

[bearbeiten] Empfänger

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 spezifiziert, dass ein Typ ein Empfänger ist
(Konzept) [bearbeiten]
(C++26)
 spezifiziert, dass ein Typ ein Empfänger für gegebene Abschluss-Signaturen ist
(Konzept) [bearbeiten]

[bearbeiten] Operationszustände

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 spezifiziert, dass ein Typ ein Operationszustand ist
(Konzept) [bearbeiten]

[bearbeiten] Hilfskomponenten

[bearbeiten] Ausführungskontexte

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 eine Ausführungsressource, die eine threadsichere MPSC-Aufgabenwarteschlange und eine manuell gesteuerte Event-Schleife enthält
(Klasse) [bearbeiten]

[bearbeiten] Ausführungsdomänen

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 Standard-Ausführungsdomänen-Tag-Typ, der Transformationen von einem Sender-Tag weiterleitet
(Klasse) [bearbeiten]
(C++26)
 wandelt in einen neuen Sender unter einer gegebenen Ausführungsdomänen-Tag um
(Funktionsvorlage) [bearbeiten]
(C++26)
 wandelt in ein neues abfragbares Objekt unter einer gegebenen Ausführungsdomänen-Tag um
(Funktionsvorlage) [bearbeiten]
(C++26)
 konsumiert einen Sender mithilfe eines gegebenen Sender-Konsumenten-Tags mit einem Satz von Argumenten und gibt dessen Ergebnis unter einem gegebenen Ausführungsdomänen-Tag zurück
(Funktionsvorlage) [bearbeiten]

[bearbeiten] Forward-Progress-Garantie

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 spezifiziert eine Forward-Progress-Garantie für Ausführungsagenten, die von der zugehörigen Ausführungsressource des Schedulers erstellt werden
(Aufzählung) [bearbeiten]

[bearbeiten] Umgebungen

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 erstellt ein abfragbares Objekt aus einem Abfrageobjekt und einem Wert
(Klassenvorlage) [bearbeiten]
(C++26)
 aggregiert mehrere abfragbare Objekte zu einem einzigen abfragbaren Objekt
(Klassenvorlage) [bearbeiten]
(C++26)
 gibt das zugehörige abfragbare Objekt für sein gegebenes Argument zurück
(Customization Point Objekt)[bearbeiten]

[bearbeiten] Abfragen

Definiert in Header <execution>
(C++26)
 fragt ein Abfrageobjekt, ob es über abfragbare Adaptoren weitergeleitet werden soll
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt ein abfragbares Objekt nach seinem zugehörigen Allocator
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt ein abfragbares Objekt nach seinem zugehörigen Stop-Token
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt ein abfragbares Objekt nach seinem zugehörigen Ausführungsdomänen-Tag
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt ein abfragbares Objekt nach seinem zugehörigen Scheduler
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt ein abfragbares Objekt nach einem Scheduler, der zur Delegation von Arbeit im Hinblick auf Forward-Progress-Delegation verwendet werden kann
(Customization Point Objekt)[bearbeiten]
(C++26)
 erlangt den Abschluss-Scheduler, der mit einem Abschluss-Tag aus den Attributen eines Senders assoziiert ist
(Customization Point Objekt)[bearbeiten]
(C++26)
 fragt einen Scheduler nach seiner execution::forward_progress_guarantee
(Customization Point Objekt)[bearbeiten]

[bearbeiten] Abschluss-Signaturen

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 Typ, der eine Menge von Abschluss-Signaturen kodiert
(Klassenvorlage) [bearbeiten]
(C++26)
 erlangt die Abschluss-Signaturen eines Senders
(Customization Point Objekt)[bearbeiten]
(C++26)
 wandelt eine Menge von Abschluss-Signaturen in eine andere um
(Aliasvorlage)[bearbeiten]
(C++26)
 wandelt die Abschluss-Signaturen eines Senders um
(Aliasvorlage)[bearbeiten]
(C++26)
 erlangt den Tag-Typ eines Senders
(Aliasvorlage)[bearbeiten]
(C++26)
 erlangt den Wert-Abschluss-Typ eines Senders
(Aliasvorlage)[bearbeiten]
(C++26)
 erlangt den Fehler-Abschluss-Typ eines Senders
(Aliasvorlage)[bearbeiten]
(C++26)
 bestimmt, ob der Sender einen gestoppten Abschluss unterstützt
(Variablenvorlage)[bearbeiten]

[bearbeiten] Coroutine-Hilfsmittel

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 wandelt einen Ausdruck in ein awaitable-Objekt innerhalb einer bestimmten Coroutine um
(Customization Point Objekt)[bearbeiten]
(C++26)
 ermöglicht, wenn als Basisklasse eines Coroutine-Promise-Typs verwendet, dass Sender innerhalb dieses Coroutine-Typs awaitable sind
(Klassenvorlage) [bearbeiten]

[bearbeiten] Kernoperationen

[bearbeiten] Operationszustand

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 verbindet einen Sender mit einem Empfänger
(Customization Point Objekt)[bearbeiten]
(C++26)
 startet die asynchrone Operation, die mit einem Operationszustand-Objekt verbunden ist
(Customization Point Objekt)[bearbeiten]

[bearbeiten] Abschlussfunktionen

Diese Funktionen werden von Sendern aufgerufen, um den Abschluss der Arbeit an ihre Empfänger anzukündigen.

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 Wert-Abschlussfunktion, die erfolgreichen Abschluss anzeigt
(Customization Point Objekt)[bearbeiten]
(C++26)
 Fehler-Abschlussfunktion, die anzeigt, dass während der Berechnung oder Planung ein Fehler aufgetreten ist
(Customization Point Objekt)[bearbeiten]
(C++26)
 gestoppte Abschlussfunktion, die anzeigt, dass eine Operation beendet wurde, bevor sie Erfolg oder Fehler erzielen konnte
(Customization Point Objekt)[bearbeiten]

[bearbeiten] Sender-Algorithmen

Dieser Abschnitt ist unvollständig
Grund: WIP-Update auf den aktuellen Standard läuft

[bearbeiten] Sender-Fabriken

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

Die folgenden sind Sender-Fabriken:

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 Akzeptiert eine variable Anzahl von Argumenten und gibt einen Sender zurück, der, wenn er verbunden und gestartet wird, synchron abschließt, indem er die Argumente an die Wert-Abschlussfunktion des Empfängers übergibt
(Customization Point Objekt)[bearbeiten]
(C++26)
 Akzeptiert ein einzelnes Argument und gibt einen Sender zurück, der, wenn er verbunden und gestartet wird, synchron abschließt, indem er das Argument an die Fehler-Abschlussfunktion des Empfängers übergibt
(Customization Point Objekt)[bearbeiten]
(C++26)
 erstellt einen Sender, der sofort abschließt, indem er die `set_stopped`-Methode seines Empfängers aufruft
(Customization Point Objekt)[bearbeiten]
(C++26)
 erstellt einen Sender, der die zugehörige Umgebung seines Empfängers abfragt
(Customization Point Objekt)[bearbeiten]
(C++26)
 bereitet einen Aufgabengraphen für die Ausführung auf einem gegebenen Scheduler vor
(Customization Point Objekt)[bearbeiten]

[bearbeiten] Pipebare Sender-Adaptoren

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 hilfreiche Basis-Klassenvorlage zur Definition eines pipebaren Sender-Adaptor-Closure-Objekts
(Klassenvorlage) [bearbeiten]

[bearbeiten] Sender-Adaptoren

Ein Sender-Adaptor ist eine Funktion, die einen Sender zurückgibt, dessen Parameter mindestens einen enthalten, dessen Typ dem sender-Konzept entspricht, und für den der zurückgegebene Sender ein Eltern-Sender der Sender-Argumente der Adaptor-Funktion ist.

Die folgenden sind Sender-Adaptoren:

Definiert in Header <execution>
Definiert im Namensraum std::execution
(C++26)
 passt einen bereitgestellten Sender so an, dass er eine Ausführung auf der Ausführungsressource des bereitgestellten Schedulers startet
(Customization Point Objekt)[bearbeiten]
(C++26)
 passt einen bereitgestellten Sender so an, dass er auf der Ausführungsressource des bereitgestellten Schedulers abschließt
(Customization Point Objekt)[bearbeiten]
(C++26)
 passt einen bereitgestellten Sender so an, dass er die Ausführung auf die Ausführungsressource eines bereitgestellten Schedulers überträgt, auf der der Sender oder die Fortsetzung ausgeführt wird, und dann die Ausführung auf die ursprüngliche Ressource zurück überträgt
(Customization Point Objekt)[bearbeiten]
(C++26)
 plant auf einer gegebenen Scheduler-Ausführungsressource Arbeit, die von der Fertigstellung eines bereitgestellten Senders abhängt
(Customization Point Objekt)[bearbeiten]
(C++26)
 verkettet den Aufgabengraphen durch den Eingabe-Sender mit einem Knoten, der das Aufrufen der bereitgestellten Funktion mit den vom Eingabe-Sender gesendeten Werten als Argumente repräsentiert
(Customization Point Objekt)[bearbeiten]
(C++26)
 verkettet den Aufgabengraphen durch den Eingabe-Sender mit einem Knoten, der das Aufrufen der bereitgestellten Funktion mit dem vom Eingabe-Sender gesendeten Fehler repräsentiert, falls ein Fehler aufgetreten ist
(Customization Point Objekt)[bearbeiten]
(C++26)
 verkettet den Aufgabengraphen durch den Eingabe-Sender mit einem Knoten, der das Aufrufen der bereitgestellten Funktion mit dem vom Eingabe-Sender gesendeten Stopp-Signal repräsentiert, falls ein "gestoppt"-Signal gesendet wird
(Customization Point Objekt)[bearbeiten]
(C++26)
 gibt einen Sender zurück, der einen Knoten repräsentiert, der an den Eingabe-Sender angehängt ist und beim Start die bereitgestellte Funktion mit den vom Eingabe-Sender gesendeten Werten als Argumenten aufruft
(Customization Point Objekt)[bearbeiten]
(C++26)
 gibt einen Sender zurück, der einen Knoten repräsentiert, der an den Eingabe-Sender angehängt ist und die bereitgestellte Funktion mit dem vom Eingabe-Sender gesendeten Fehler aufruft, falls einer aufgetreten ist
(Customization Point Objekt)[bearbeiten]
(C++26)
 gibt einen Sender zurück, der einen Knoten repräsentiert, der an den Eingabe-Sender angehängt ist und die bereitgestellte Funktion mit dem Stopp-Token vom Eingabe-Sender aufruft, falls das "gestoppt"-Signal gesendet wird
(Customization Point Objekt)[bearbeiten]
(C++26)
 erstellt einen Multi-Shot-Sender, der die Funktion mit jedem Index innerhalb der bereitgestellten Form zusammen mit den vom Eingabe-Sender gesendeten Werten aufruft. Der Sender schließt ab, sobald alle Aufrufe abgeschlossen sind oder ein Fehler aufgetreten ist.
(Customization Point Objekt)[bearbeiten]
(C++26)
 wenn der bereitgestellte Sender ein Multi-Shot-Sender ist, gibt er diesen Sender zurück, andernfalls gibt er einen Multi-Shot-Sender zurück, der Werte sendet, die äquivalent zu den vom bereitgestellten Sender gesendeten Werten sind
(Customization Point Objekt)[edit]
(C++26)
 passt mehrere Eingabe-Sender zu einem Sender an, der abschließt, sobald alle Eingabe-Sender abgeschlossen sind
(Customization Point Objekt)[edit]
(C++26)
 passt mehrere Eingabe-Sender an, wobei jeder möglicherweise mehrere Abschluss-Signaturen hat, zu einem Sender, der abschließt, sobald alle Eingabe-Sender abgeschlossen sind
(Customization Point Objekt)[edit]
(C++26)
 gibt einen Sender zurück, der eine Variante von Tupeln aller möglichen Typensätze sendet, die vom Eingabe-Sender gesendet werden
(Customization Point Objekt)[edit]
(C++26)
 gibt einen Sender zurück, der den Wertkanal auf std::optional<std::decay_t<T>> und den gestoppten Kanal auf std::nullopt abbildet
(Customization Point Objekt)[edit]
(C++26)
 gibt einen Sender zurück, der den gestoppten Kanal auf einen Fehler abbildet
(Customization Point Objekt)[edit]

[edit] Sender consumers

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

Definiert in Header <execution>
Definiert im Namespace std::this_thread
(C++26)
 blockiert den aktuellen Thread, bis der angegebene Sender abgeschlossen ist und sein asynchrones Ergebnis zurückgibt
(Customization Point Objekt)[edit]
(C++26)
 blockiert den aktuellen Thread, bis der angegebene Sender mit möglicherweise mehreren Abschluss-Signaturen abgeschlossen ist und sein asynchrones Ergebnis zurückgibt
(Customization Point Objekt)[edit]

[edit] Beispiel

Eine Version dieses Beispiels ist auf godbolt.org verfügbar, wo sie stdexec verwendet, eine experimentelle Referenzimplementierung von std::execution.

Führen Sie diesen Code aus
#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;
}

Ausgabe

hello world

[edit] Siehe auch

(C++11)
 führt eine Funktion asynchron aus (potenziell in einem neuen Thread) und gibt ein std::future zurück, das das Ergebnis enthalten wird
(Funktionsvorlage) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/execution&oldid=181104"