WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Konstanten für Algorithmus-Ausführungsrichtlinien

Die Objekte std::execution::seq, std::execution::par, std::execution::par_unseq und std::execution::unseq legen fest, auf welche Weise ein Algorithmus ausgeführt werden darf. Sie garantieren keine Beschleunigung; die Wahl einer Richtlinie verändert auch die Anforderungen an Funktionen, die Elemente verarbeiten.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

#include <algorithm>
#include <execution>

std::execution::seq
std::execution::par
std::execution::par_unseq
std::execution::unseq

std::transform(policy, first, last, output, operation);

Der Header <execution> stellt vier inline constexpr-Objekte bereit, keine Funktionen oder Enumerationswerte. Übergeben Sie eines davon als erstes Argument an eine Überladung eines Algorithmus, die Ausführungsrichtlinien unterstützt, etwa std::transform. Ihre Typen sind der Reihe nach sequenced_policy, parallel_policy, parallel_unsequenced_policy und unsequenced_policy in std::execution.

std::execution::seq verlangt eine sequenzielle Ausführung im aufrufenden Thread. std::execution::par erlaubt mehrere Threads, aber Aufrufe der Elementverarbeitungsfunktion innerhalb eines Threads überschneiden sich nicht. std::execution::par_unseq erlaubt sowohl mehrere Threads als auch nicht sequenzierte Aufrufe innerhalb jedes Threads und ermöglicht dadurch Vektorisierung. std::execution::unseq erlaubt nicht sequenzierte Aufrufe im aufrufenden Thread, jedoch keine zusätzlichen Threads. Die Richtlinien räumen Möglichkeiten ein, garantieren aber weder Parallelität noch Vektorisierung oder Beschleunigung; sequenzielle Ausführung ist zulässig.

Verlassen Sie sich weder auf die Reihenfolge der Elementverarbeitung noch darauf, dass eine andere Iteration gleichzeitig ausgeführt wird. Verhindern Sie Datenrennen. Bei unseq und par_unseq führt der Aufruf einer vektorisierungsunsicheren Funktion der Standardbibliothek zu undefiniertem Verhalten; vermeiden Sie es, in der Elementverarbeitungsfunktion Mutexes zu sperren. Bei allen vier Richtlinien führt eine Ausnahme, die aus dieser Funktion entweicht, zum Aufruf von std::terminate, auch bei seq. Kann temporärer Speicher, der für die Parallelisierung benötigt wird, nicht beschafft werden, kann std::bad_alloc ausgelöst werden.

Das Beispiel berechnet unabhängig voneinander Quadrate und gibt Ergebnisse erst aus, wenn jeder Algorithmus beendet ist. Alle Richtlinien liefern dasselbe erwartete Ergebnis; dies ist keine Leistungsmessung. Dieser Eintrag bezieht sich auf C++23; ein Compiler-Flag des Repositorys belegt keine Unterstützung in der Produktionslaufzeit.

Beispiele

#include <algorithm>
#include <array>
#include <cstddef>
#include <execution>
#include <iostream>

int main() {
    const std::array<int, 4> input{1, 2, 3, 4};

    const auto run = [&](auto policy) {
        std::array<int, 4> output{};
        std::transform(policy, input.begin(), input.end(), output.begin(),
                       [](int value) noexcept { return value * value; });
        for (std::size_t i = 0; i < output.size(); ++i) {
            if (i != 0) std::cout << ' ';
            std::cout << output[i];
        }
        std::cout << '\n';
    };

    run(std::execution::seq);
    run(std::execution::par);
    run(std::execution::par_unseq);
    run(std::execution::unseq);
}

Ergebnis

1 4 9 16
1 4 9 16
1 4 9 16
1 4 9 16

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen