Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Constantes de politique d’exécution des algorithmes

Les objets std::execution::seq, std::execution::par, std::execution::par_unseq et std::execution::unseq définissent les modes d’exécution autorisés pour un algorithme. Ils ne garantissent aucun gain de vitesse ; le choix d’une politique modifie également les exigences applicables aux fonctions qui traitent les éléments.

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

Syntaxe

#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’en-tête <execution> fournit quatre objets inline constexpr, et non des fonctions ou des valeurs d’énumération. Passez-en un comme premier argument à une surcharge d’algorithme prenant en charge les politiques d’exécution, par exemple std::transform. Leurs types respectifs dans std::execution sont sequenced_policy, parallel_policy, parallel_unsequenced_policy et unsequenced_policy.

std::execution::seq exige une exécution séquentielle dans le thread appelant. std::execution::par autorise plusieurs threads, mais les appels de la fonction de traitement des éléments ne se chevauchent pas au sein d’un même thread. std::execution::par_unseq autorise à la fois plusieurs threads et des appels non séquencés dans chacun d’eux, ce qui permet la vectorisation. std::execution::unseq autorise des appels non séquencés dans le thread appelant, sans autoriser de threads supplémentaires. Les politiques accordent des possibilités, mais ne garantissent ni parallélisme, ni vectorisation, ni gain de vitesse ; une exécution séquentielle reste autorisée.

Ne dépendez ni de l’ordre de traitement des éléments ni de l’exécution simultanée d’une autre itération. Évitez les courses de données. Avec unseq et par_unseq, l’appel d’une fonction de la bibliothèque standard non sûre pour la vectorisation entraîne un comportement indéfini ; évitez de verrouiller des mutex dans la fonction de traitement des éléments. Pour les quatre politiques, toute exception qui s’échappe de cette fonction appelle std::terminate, même avec seq. L’impossibilité d’obtenir la mémoire temporaire nécessaire à la parallélisation peut entraîner une exception std::bad_alloc.

L’exemple calcule des carrés indépendamment et n’affiche les résultats qu’une fois chaque algorithme terminé. Toutes les politiques produisent le même résultat attendu ; il ne s’agit pas d’une mesure de performance. Cette entrée vise C++23 ; un indicateur de compilation du dépôt ne prouve pas la prise en charge par l’environnement d’exécution de production.

Exemples

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

Résultat

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

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources