KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Constanten voor uitvoeringsbeleid van algoritmen

De objecten std::execution::seq, std::execution::par, std::execution::par_unseq en std::execution::unseq geven aan hoe een algoritme uitgevoerd mag worden. Ze garanderen geen snelheidswinst; de keuze van een beleid verandert ook de eisen aan functies die elementen verwerken.

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

Syntax

#include <algorithm>
#include <execution>

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

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

De header <execution> biedt vier inline constexpr-objecten, geen functies of enumeratiewaarden. Geef er een als eerste argument mee aan een algoritme-overload die uitvoeringsbeleid ondersteunt, zoals std::transform. Hun typen zijn respectievelijk sequenced_policy, parallel_policy, parallel_unsequenced_policy en unsequenced_policy in std::execution.

std::execution::seq vereist sequentiële uitvoering in de aanroepende thread. std::execution::par staat meerdere threads toe, maar aanroepen van de elementverwerkende functie overlappen niet binnen één thread. std::execution::par_unseq staat zowel meerdere threads als niet-gesequenceerde aanroepen binnen elke thread toe, waardoor vectorisatie mogelijk is. std::execution::unseq staat niet-gesequenceerde aanroepen in de aanroepende thread toe, zonder extra threads toe te staan. Beleidskeuzes geven toestemming, maar garanderen geen parallelisme, vectorisatie of snelheidswinst; sequentiële uitvoering is toegestaan.

Vertrouw niet op de volgorde waarin elementen worden verwerkt of op gelijktijdige uitvoering van een andere iteratie. Voorkom dataraces. Bij unseq en par_unseq leidt het aanroepen van een vectorisatie-onveilige functie uit de standaardbibliotheek tot ongedefinieerd gedrag; vergrendel geen mutexen in de elementverwerkende functie. Bij alle vier beleidskeuzes roept een uitzondering die uit die functie ontsnapt std::terminate aan, ook bij seq. Als tijdelijke geheugenruimte die nodig is voor parallelisering niet beschikbaar is, kan std::bad_alloc optreden.

Het voorbeeld berekent onafhankelijk kwadraten en geeft resultaten pas weer nadat elk algoritme is voltooid. Alle beleidskeuzes leveren hetzelfde verwachte resultaat op; dit is geen prestatiemeting. Dit artikel richt zich op C++23; een compileroptie van de repository bewijst geen ondersteuning in de productie-runtime.

Voorbeelden

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

Resultaat

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

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen