Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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.

Fonti