CKTIS / C++
Costanti delle policy di esecuzione degli algoritmi
Gli oggetti std::execution::seq, std::execution::par, std::execution::par_unseq e std::execution::unseq specificano le modalità di esecuzione consentite per un algoritmo. Non garantiscono un aumento della velocità; la scelta di una policy modifica anche i requisiti delle funzioni che elaborano gli elementi.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <algorithm>
#include <execution>
std::execution::seq
std::execution::par
std::execution::par_unseq
std::execution::unseq
std::transform(policy, first, last, output, operation);L’header <execution> fornisce quattro oggetti inline constexpr, non funzioni né valori di enumerazione. Passarne uno come primo argomento a un overload di algoritmo che supporta le policy di esecuzione, come std::transform. I rispettivi tipi in std::execution sono sequenced_policy, parallel_policy, parallel_unsequenced_policy e unsequenced_policy.
std::execution::seq richiede l’esecuzione sequenziale nel thread chiamante. std::execution::par consente più thread, ma le chiamate alla funzione che elabora gli elementi non si sovrappongono all’interno dello stesso thread. std::execution::par_unseq consente sia più thread sia chiamate non sequenziate in ciascun thread, rendendo possibile la vettorizzazione. std::execution::unseq consente chiamate non sequenziate nel thread chiamante, senza autorizzare thread aggiuntivi. Le policy concedono possibilità, ma non garantiscono parallelismo, vettorizzazione o aumenti di velocità; l’esecuzione sequenziale è consentita.
Non fare affidamento sull’ordine di elaborazione degli elementi né sull’esecuzione simultanea di un’altra iterazione. Previeni le race condition. Con unseq e par_unseq, chiamare una funzione della libreria standard non sicura per la vettorizzazione causa comportamento indefinito; evita di bloccare mutex nella funzione che elabora gli elementi. Per tutte e quattro le policy, un’eccezione che esce da tale funzione invoca std::terminate, anche con seq. L’impossibilità di ottenere la memoria temporanea necessaria alla parallelizzazione può causare std::bad_alloc.
L’esempio calcola i quadrati in modo indipendente e stampa i risultati solo dopo il completamento di ciascun algoritmo. Tutte le policy producono lo stesso risultato previsto; non è una misura delle prestazioni. Questa voce riguarda C++23; un’opzione del compilatore del repository non attesta il supporto nell’ambiente di produzione.
Esempi
#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);
}
Risultato
1 4 9 16 1 4 9 16 1 4 9 16 1 4 9 16
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.