Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Constantes das políticas de execução de algoritmos

Os objetos std::execution::seq, std::execution::par, std::execution::par_unseq e std::execution::unseq especificam como um algoritmo pode ser executado. Não garantem um aumento de velocidade; a escolha de uma política também altera os requisitos das funções que processam elementos.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <algorithm>
#include <execution>

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

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

O cabeçalho <execution> disponibiliza quatro objetos inline constexpr, não funções nem valores de enumeração. Passe um deles como primeiro argumento a uma sobrecarga de algoritmo que aceite políticas de execução, como std::transform. Os respetivos tipos em std::execution são sequenced_policy, parallel_policy, parallel_unsequenced_policy e unsequenced_policy.

std::execution::seq exige execução sequencial na thread chamadora. std::execution::par permite várias threads, mas as chamadas à função que processa elementos não se sobrepõem dentro da mesma thread. std::execution::par_unseq permite tanto várias threads como chamadas não sequenciadas em cada thread, possibilitando a vetorização. std::execution::unseq permite chamadas não sequenciadas na thread chamadora, sem permitir threads adicionais. As políticas concedem permissões, mas não garantem paralelismo, vetorização ou aumento de velocidade; a execução sequencial é permitida.

Não dependa da ordem de processamento dos elementos nem de outra iteração ser executada em simultâneo. Evite condições de corrida. Com unseq e par_unseq, chamar uma função da biblioteca padrão que não seja segura para vetorização provoca comportamento indefinido; evite bloquear mutexes dentro da função que processa elementos. Para as quatro políticas, uma exceção que saia dessa função invoca std::terminate, mesmo com seq. A impossibilidade de obter a memória temporária necessária para paralelizar pode causar std::bad_alloc.

O exemplo calcula quadrados de forma independente e só apresenta os resultados depois de cada algoritmo terminar. Todas as políticas produzem o mesmo resultado esperado; isto não é uma medição de desempenho. Esta entrada diz respeito a C++23; uma opção de compilação do repositório não comprova o suporte no ambiente de execução de produção.

Exemplos

#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);
}

Resultado

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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes