Namespaces
Variants

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

Von de.cppreference.net
 
 
Algorithmenbibliothek
Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
Eingeschränkte Algorithmen, z. B. ranges::copy, ranges::sort, ...
Nicht modifizierende Sequenzoperationen    
Stapeloperationen
(C++17)
Suchoperationen
Modifizierende Sequenzoperationen
Kopieroperationen
(C++11)
(C++11)
Tauschoperationen
Transformationsoperationen
Generierungsoperationen
Entfernungsoperationen
Reihenfolgeändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortier- und verwandte Operationen
Partitionierungsoperationen
(C++11)    

Sortieroperationen
Binäre Suchoperationen
(auf partitionierten Bereichen)
Mengenoperationen (auf sortierten Bereichen)
Mischoperationen (auf sortierten Bereichen)
Heap-Operationen
Minimum/Maximum-Operationen
(C++11)
(C++17)
Lexikografische Vergleichsoperationen
Permutationsoperationen


 
Definiert in Header <execution>
inline constexpr
std::execution::sequenced_policy seq { /* unspecified */ };
(seit C++17)
inline constexpr
std::execution::parallel_policy par { /* unspecified */ };
(seit C++17)
inline constexpr
std::execution::parallel_unsequenced_policy par_unseq { /* unspecified */ };
(seit C++17)
inline constexpr
std::execution::unsequenced_policy unseq { /* unspecified */ };
(seit C++20)

Die Ausführungsrichtlinientypen

  • std::execution::sequenced_policy,
  • std::execution::parallel_policy,
  • std::execution::parallel_unsequenced_policy, und
  • std::execution::unsequenced_policy

haben die folgenden jeweiligen Instanzen:

  • std::execution::seq,
  • std::execution::par,
  • std::execution::par_unseq, und
  • std::execution::unseq.

Diese Instanzen werden verwendet, um die Ausführungsrichtlinie von parallelen Algorithmen anzugeben, d.h. die erlaubten Arten der Parallelität.

Zusätzliche Ausführungsrichtlinien können von einer Implementierung der Standardbibliothek bereitgestellt werden (mögliche zukünftige Ergänzungen können std::parallel::cuda und std::parallel::opencl umfassen).

Beispiel

#include <algorithm>
#include <chrono>
#include <cstdint>
#include <iostream>
#include <random>
#include <vector>

#ifdef PARALLEL
#include <execution>
    namespace execution = std::execution;
#else
    enum class execution { seq, unseq, par_unseq, par };
#endif

void measure([[maybe_unused]] auto policy, std::vector<std::uint64_t> v)
{
    const auto start = std::chrono::steady_clock::now();
#ifdef PARALLEL
    std::sort(policy, v.begin(), v.end());
#else
    std::sort(v.begin(), v.end());
#endif
    const auto finish = std::chrono::steady_clock::now();
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(finish - start)
              << '\n';
};

int main()
{
    std::vector<std::uint64_t> v(1'000'000);
    std::mt19937 gen {std::random_device{}()};
    std::ranges::generate(v, gen);

    measure(execution::seq, v);
    measure(execution::unseq, v);
    measure(execution::par_unseq, v);
    measure(execution::par, v);
}

Mögliche Ausgabe:

// online GNU/gcc compiler (PARALLEL macro is not defined)
81ms
80ms
79ms
78ms

// with g++ -std=c++23 -O3 ./test.cpp -ltbb -DPARALLEL
165ms
163ms
30ms
27ms

Siehe auch

Ausführungsrichtlinientypen
(Klasse)