Naamruimtefuncties voor gelijktijdigheid

Alloc

Wijst een blok geheugen toe van de grootte die is opgegeven vanuit de Suballocator voor gelijktijdigheidsruntime.

void* __cdecl Alloc(size_t _NumBytes);

Parameterwaarden

_NumBytes
Het aantal bytes aan geheugen dat moet worden toegewezen.

Retourwaarde

Een aanwijzer naar nieuw toegewezen geheugen.

Opmerkingen

Zie Task Schedulervoor meer informatie over welke scenario's in uw toepassing baat kunnen hebben bij het gebruik van suballocator voor caching.

asend

Een asynchrone verzendbewerking, waarmee een taak wordt gepland om de gegevens door te geven aan het doelblok.

template <class T>
bool asend(
    _Inout_ ITarget<T>* _Trg,
    const T& _Data);

template <class T>
bool asend(
    ITarget<T>& _Trg,
    const T& _Data);

Parameterwaarden

T-
Het type gegevens dat moet worden verzonden.

_Trg
Een aanwijzer of verwijzing naar het doel waarnaar gegevens worden verzonden.

_Gegevens
Een verwijzing naar de gegevens die moeten worden verzonden.

Retourwaarde

true als het bericht is geaccepteerd voordat de methode werd geretourneerd, false anders.

Opmerkingen

Zie Message Passing Functionsvoor meer informatie.

cancel_current_task

Hiermee wordt de momenteel uitgevoerde taak geannuleerd. Deze functie kan worden aangeroepen vanuit de hoofdtekst van een taak om de uitvoering van de taak af te breken en ervoor te zorgen dat deze de status canceled invoert.

Het is geen ondersteund scenario om deze functie aan te roepen als u zich niet in de hoofdtekst van een taskbevindt. Als u dit doet, resulteert dit in niet-gedefinieerd gedrag, zoals een crash of niet-reactievermogen in uw toepassing.

inline __declspec(noreturn) void __cdecl cancel_current_task();

duidelijk

Hiermee wordt de gelijktijdige wachtrij gewist, waardoor alle momenteel niet-geïntenseerde elementen worden vernietigd. Deze methode is niet gelijktijdigheidsveilig.

template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();

Parameterwaarden

T-

_Bijl

create_async

Hiermee maakt u een asynchrone Windows Runtime-constructie op basis van een door de gebruiker opgegeven lambda- of functieobject. Het retourtype van create_async is een van de IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^of IAsyncOperationWithProgress<TResult, TProgress>^ op basis van de handtekening van de lambda die aan de methode is doorgegeven.

template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
    -> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));

Parameterwaarden

_Functie
Type

_Func
Het lambda- of functieobject waaruit een asynchrone Windows Runtime-constructie moet worden gemaakt.

Retourwaarde

Een asynchrone constructie die wordt vertegenwoordigd door een IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^of een IAsyncOperationWithProgress<TResult, TProgress>^. De geretourneerde interface is afhankelijk van de handtekening van de lambda die in de functie is doorgegeven.

Opmerkingen

Het retourtype van de lambda bepaalt of de constructie een actie of een bewerking is.

Lambdas die ongeldigheid retourneert, veroorzaakt het maken van acties. Lambdas die een resultaat retourneert van het type TResult leiden tot het maken van bewerkingen van TResult.

De lambda kan ook een task<TResult> functie retourneren die het asynchrone werk op zichzelf inkapselt of de voortzetting is van een keten van taken die het asynchrone werk vertegenwoordigen. In dit geval wordt de lambda zelf inline uitgevoerd, omdat de taken asynchroon worden uitgevoerd en het retourtype van de lambda wordt uitgepakt om de asynchrone constructie te produceren die wordt geretourneerd door create_async. Dit impliceert dat een lambda die een taak retourneert<ongeldige> het maken van acties veroorzaakt, en een lambda die een taak retourneert<TResult-> leidt tot het maken van bewerkingen van TResult.

De lambda kan nul, één of twee argumenten hebben. De geldige argumenten zijn progress_reporter<TProgress> en cancellation_token, in die volgorde als beide worden gebruikt. Een lambda zonder argumenten zorgt ervoor dat een asynchrone constructie wordt gemaakt zonder de mogelijkheid voor voortgangsrapportage. Een lambda die een progress_reporter<TProgress-> gebruikt, zorgt ervoor dat create_async een asynchrone constructie retourneert die de voortgang van het type TProgress rapporteert telkens wanneer de report methode van het progress_reporter-object wordt aangeroepen. Een lambda die een cancellation_token gebruikt, kan dat token gebruiken om te controleren op annulering of door te geven aan taken die het maakt, zodat de annulering van de asynchrone constructie leidt tot annulering van deze taken.

Als de hoofdtekst van het lambda- of functieobject een resultaat retourneert (en niet een taak-TResult<>), wordt de lambda asynchroon uitgevoerd binnen het proces MTA in de context van een taak die de Runtime impliciet voor deze taak maakt. De methode IAsyncInfo::Cancel veroorzaakt annulering van de impliciete taak.

Als de hoofdtekst van de lambda een taak retourneert, wordt de lambda inline uitgevoerd en door de lambda te declareren om een argument van het type cancellation_token te gebruiken, kunt u annulering activeren van alle taken die u in de lambda maakt door dat token door te geven wanneer u ze maakt. U kunt ook de methode register_callback op het token gebruiken om ervoor te zorgen dat runtime een callback aanroept wanneer u IAsyncInfo::Cancel aanroept voor de asynchrone bewerking of actie die is geproduceerd.

Deze functie is alleen beschikbaar voor Windows Runtime-apps.

CreateResourceManager

Hiermee wordt een interface geretourneerd die het singleton-exemplaar van Resource Manager van de Gelijktijdigheidsruntime vertegenwoordigt. Resource Manager is verantwoordelijk voor het toewijzen van resources aan planners die met elkaar willen samenwerken.

IResourceManager* __cdecl CreateResourceManager();

Retourwaarde

Een IResourceManager interface.

Opmerkingen

Meerdere volgende aanroepen naar deze methode retourneren hetzelfde exemplaar van Resource Manager. Elke aanroep van de methode incrementeert een verwijzingsaantal op resourcebeheer en moet worden gekoppeld aan een aanroep naar de methode IResourceManager::Release wanneer uw planner klaar is met de communicatie met Resource Manager.

unsupported_os wordt gegenereerd als het besturingssysteem niet wordt ondersteund door de Gelijktijdigheidsruntime.

create_task

Hiermee maakt u een PPL-taak-object. create_task kan overal worden gebruikt waar u een taakconstructor zou hebben gebruikt. Het wordt voornamelijk voor het gemak geleverd, omdat het het gebruik van het auto trefwoord tijdens het maken van taken toestaat.

template<typename T>
__declspec(noinline) auto create_task(T _Param, const task_options& _TaskOptions = task_options())
    -> task<typename details::_TaskTypeFromParam<T>::T>;

template<typename _ReturnType>
__declspec( noinline) task<_ReturnType> create_task(const task<_ReturnType>& _Task);

Parameterwaarden

T-
Het type parameter waaruit de taak moet worden samengesteld.

_ReturnType
Type

_Param
De parameter waaruit de taak moet worden samengesteld. Dit kan een lambda- of functieobject, een task_completion_event-object, een ander task-object of een Windows::Foundation::IAsyncInfo-interface zijn als u taken in uw UWP-app gebruikt.

_TaskOptions
De taakopties.

_Taak
De taak die moet worden gemaakt.

Retourwaarde

Een nieuwe taak van het type T, die wordt afgeleid van _Param.

Opmerkingen

De eerste overbelasting gedraagt zich als een taakconstructor die één parameter gebruikt.

De tweede overbelasting koppelt het annuleringstoken aan de zojuist gemaakte taak. Als u deze overbelasting gebruikt, mag u geen ander task object doorgeven als de eerste parameter.

Het type geretourneerde taak wordt afgeleid van de eerste parameter naar de functie. Als _Param een task_completion_event<T>, een task<T>of een functor is die een type T of task<T>retourneert, wordt het type van de gemaakte taak task<T>.

Als _Param in een UWP-app van het type Windows::Foundation::IAsyncOperation<T>^ of Windows::Foundation::IAsyncOperationWithProgress<T,P>^of een functor die een van deze typen retourneert, is de gemaakte taak van het type task<T>. Als _Param van het type Windows::Foundation::IAsyncAction^ of Windows::Foundation::IAsyncActionWithProgress<P>^, of een functor die een van deze typen retourneert, heeft de gemaakte taak het type task<void>.

DisableTracing

Hiermee schakelt u tracering uit in de Gelijktijdigheidsruntime. Deze functie is afgeschaft omdat ETW-tracering standaard niet is geregistreerd.

__declspec(deprecated("Concurrency::DisableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl DisableTracing();

Retourwaarde

Als tracering correct is uitgeschakeld, wordt S_OK geretourneerd. Als tracering niet eerder is gestart, wordt E_NOT_STARTED geretourneerd

EnableTracing

Hiermee schakelt u tracering in de Gelijktijdigheidsruntime in. Deze functie is afgeschaft omdat ETW-tracering nu standaard is ingeschakeld.

__declspec(deprecated("Concurrency::EnableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl EnableTracing();

Retourwaarde

Als tracering correct is geïnitieerd, wordt S_OK geretourneerd; anders wordt E_NOT_STARTED geretourneerd.

Vrij

Hiermee wordt een geheugenblok uitgebracht dat eerder door de Alloc methode is toegewezen aan de Suballocator voor gelijktijdigheidsruntime caching.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parameterwaarden

_PAllocation
Een aanwijzer naar het geheugen dat eerder is toegewezen door de Alloc methode die moet worden vrijgemaakt. Als de parameter _PAllocation is ingesteld op de waarde NULL, wordt deze door deze methode genegeerd en onmiddellijk geretourneerd.

Opmerkingen

Zie Task Schedulervoor meer informatie over welke scenario's in uw toepassing baat kunnen hebben bij het gebruik van suballocator voor caching.

get_ambient_scheduler

inline std::shared_ptr<::Concurrency::scheduler_interface> get_ambient_scheduler();

Retourwaarde

GetExecutionContextId

Retourneert een unieke id die kan worden toegewezen aan een uitvoeringscontext waarmee de IExecutionContext-interface wordt geïmplementeerd.

unsigned int __cdecl GetExecutionContextId();

Retourwaarde

Een unieke id voor een uitvoeringscontext.

Opmerkingen

Gebruik deze methode om een id te verkrijgen voor de uitvoeringscontext voordat u een IExecutionContext-interface als parameter doorgeeft aan een van de methoden die door Resource Manager worden aangeboden.

GetOSVersion

Retourneert de versie van het besturingssysteem.

IResourceManager::OSVersion __cdecl GetOSVersion();

Retourwaarde

Een opgesomde waarde die het besturingssysteem vertegenwoordigt.

Opmerkingen

unsupported_os wordt gegenereerd als het besturingssysteem niet wordt ondersteund door de Gelijktijdigheidsruntime.

GetProcessorCount

Retourneert het aantal hardwarethreads op het onderliggende systeem.

unsigned int __cdecl GetProcessorCount();

Retourwaarde

Het aantal hardwarethreads.

Opmerkingen

unsupported_os wordt gegenereerd als het besturingssysteem niet wordt ondersteund door de Gelijktijdigheidsruntime.

GetProcessorNodeCount

Retourneert het aantal NUMA-knooppunten of processorpakketten op het onderliggende systeem.

unsigned int __cdecl GetProcessorNodeCount();

Retourwaarde

Het aantal NUMA-knooppunten of processorpakketten.

Opmerkingen

Als het systeem meer NUMA-knooppunten bevat dan processorpakketten, wordt het aantal NUMA-knooppunten geretourneerd, anders wordt het aantal processorpakketten geretourneerd.

unsupported_os wordt gegenereerd als het besturingssysteem niet wordt ondersteund door de Gelijktijdigheidsruntime.

GetSchedulerId

Retourneert een unieke id die kan worden toegewezen aan een planner waarmee de IScheduler-interface wordt geïmplementeerd.

unsigned int __cdecl GetSchedulerId();

Retourwaarde

Een unieke id voor een planner.

Opmerkingen

Gebruik deze methode om een id voor uw scheduler op te halen voordat u een IScheduler-interface als parameter doorgeeft aan een van de methoden die door Resource Manager worden aangeboden.

internal_assign_iterators

template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
   _I first,
   _I last);

Parameterwaarden

T-

_Bijl

_Ik

eerste

laatste

interruption_point

Hiermee maakt u een onderbrekingspunt voor annulering. Als er een annulering wordt uitgevoerd in de context waarin deze functie wordt aangeroepen, genereert dit een interne uitzondering waardoor de uitvoering van het huidige parallelle werk wordt afgebroken. Als de annulering niet wordt uitgevoerd, doet de functie niets.

inline void interruption_point();

Opmerkingen

U moet de interne annuleringsuitzondering die is gegenereerd door de interruption_point() functie niet ondervangen. De uitzondering wordt door de runtime onderschept en verwerkt en kan ertoe leiden dat uw programma zich abnormaal gedraagt.

is_current_task_group_canceling

Retourneert een indicatie of de taakgroep die momenteel inline wordt uitgevoerd op de huidige context zich midden in een actieve annulering bevindt (of binnenkort zal zijn). Houd er rekening mee dat als er momenteel geen taakgroep inline wordt uitgevoerd in de huidige context, false wordt geretourneerd.

bool __cdecl is_current_task_group_canceling();

Retourwaarde

true als de taakgroep die momenteel wordt uitgevoerd, wordt geannuleerd, false anders.

Opmerkingen

Zie Annuleringvoor meer informatie.

make_choice

Hiermee maakt u een choice berichtenblok van een optionele Scheduler of ScheduleGroup en twee of meer invoerbronnen.

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    Scheduler& _PScheduler,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    ScheduleGroup& _PScheduleGroup,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

Parameterwaarden

T1-
Het type berichtblok van de eerste bron.

T2-
Het type berichtblok van de tweede bron.

_PScheduler
Het Scheduler-object waarin de doorgiftetaak voor het berichtblok choice is gepland.

_Item1
De eerste bron.

_Item2
De tweede bron.

_Items
Aanvullende bronnen.

_PScheduleGroup
Het ScheduleGroup-object waarin de doorgiftetaak voor het berichtblok choice is gepland. Het gebruikte Scheduler-object wordt geïmpliceerd door de planningsgroep.

Retourwaarde

Een choice berichtblok met twee of meer invoerbronnen.

make_greedy_join

Hiermee maakt u een greedy multitype_join berichtenblok van een optionele Scheduler of ScheduleGroup en twee of meer invoerbronnen.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>,greedy> make_greedy_join(
    Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    T1 _Item1,
    T2 _Items,
    Ts... _Items);

Parameterwaarden

T1-
Het type berichtblok van de eerste bron.

T2-
Het type berichtblok van de tweede bron.

_PScheduler
Het Scheduler-object waarin de doorgiftetaak voor het berichtblok multitype_join is gepland.

_Item1
De eerste bron.

_Item2
De tweede bron.

_Items
Aanvullende bronnen.

_PScheduleGroup
Het ScheduleGroup-object waarin de doorgiftetaak voor het berichtblok multitype_join is gepland. Het gebruikte Scheduler-object wordt geïmpliceerd door de planningsgroep.

Retourwaarde

Een greedy multitype_join berichtblok met twee of meer invoerbronnen.

make_join

Hiermee maakt u een non_greedy multitype_join berichtenblok van een optionele Scheduler of ScheduleGroup en twee of meer invoerbronnen.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>>
    make_join(
Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

Parameterwaarden

T1-
Het type berichtblok van de eerste bron.

T2-
Het type berichtblok van de tweede bron.

_PScheduler
Het Scheduler-object waarin de doorgiftetaak voor het berichtblok multitype_join is gepland.

_Item1
De eerste bron.

_Item2
De tweede bron.

_Items
Aanvullende bronnen.

_PScheduleGroup
Het ScheduleGroup-object waarin de doorgiftetaak voor het berichtblok multitype_join is gepland. Het gebruikte Scheduler-object wordt geïmpliceerd door de planningsgroep.

Retourwaarde

Een non_greedy multitype_join berichtblok met twee of meer invoerbronnen.

make_task

Een factorymethode voor het maken van een task_handle-object.

template <class _Function>
task_handle<_Function> make_task(const _Function& _Func);

Parameterwaarden

_Functie
Het type van het functieobject dat wordt aangeroepen om het werk uit te voeren dat wordt vertegenwoordigd door het task_handle-object.

_Func
De functie die wordt aangeroepen om het werk uit te voeren dat wordt vertegenwoordigd door het task_handle-object. Dit kan een lambda functor, een aanwijzer naar een functie of een object zijn dat een versie van de operator voor functieoproep ondersteunt met de handtekening void operator()().

Retourwaarde

Een task_handle-object.

Opmerkingen

Deze functie is handig wanneer u een task_handle object met een lambda-expressie moet maken, omdat u hiermee het object kunt maken zonder het ware type lambda functor te kennen.

parallel_buffered_sort

Rangschikt de elementen in een opgegeven bereik in een niet-aflopende volgorde, of volgens een rangordecriterium dat is opgegeven door een binair predicaat, parallel. Deze functie is semantisch vergelijkbaar met std::sort omdat het een op vergelijking gebaseerde, instabiele, in-place sortering is, behalve dat deze O(n) extra ruimte nodig heeft en standaard initialisatie vereist voor de elementen die worden gesorteerd.

template<typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Parameterwaarden

_Random_iterator
Het iteratortype van het invoerbereik.

_Allocator
Het type C++-standaardbibliotheek dat compatibel is met geheugentoewijzing.

_Functie
Het type binaire comparator.

_Beginnen
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden gesorteerd.

_Einde
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om te worden gesorteerd.

_Alloc
Een exemplaar van een C++-standaardbibliotheek die compatibel is met geheugentoewijzing.

_Func
Een door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan. Deze comparatorfunctie moet een strikte zwakke volgorde opleggen aan paren elementen uit de reeks.

_Chunk_size
De mimimumgrootte van een segment dat in tweeën wordt gesplitst voor parallelle uitvoering.

Opmerkingen

Voor alle overbelastingen is n * sizeof(T) extra ruimte vereist, waarbij n het aantal elementen is dat moet worden gesorteerd en T het elementtype is. In de meeste gevallen toont parallel_buffered_sort een verbetering van de prestaties ten opzichte van parallel_sorten moet u deze over parallel_sort gebruiken als u het geheugen beschikbaar hebt.

Als u geen binaire comparator opgeeft std::less wordt gebruikt als de standaardinstelling. Hiervoor moet het elementtype de operator operator<()opgeven.

Als u geen allocatortype of instantie opgeeft, wordt de C++ Standard Library Memory Allocator std::allocator<T> gebruikt om de buffer toe te wijzen.

Het algoritme verdeelt het invoerbereik in twee segmenten en verdeelt elk segment achtereenvolgens in twee subsegmenten voor uitvoering parallel. Het optionele argument _Chunk_size kan worden gebruikt om aan te geven aan het algoritme dat het segmenten van grootte moet verwerken <_Chunk_size serieel.

parallel_for

parallel_for doorloopt een reeks indexen en voert een door de gebruiker geleverde functie parallel uit bij elke iteratie.

template <typename _Index_type, typename _Function, typename _Partitioner>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func,
    _Partitioner&& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const static_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const simple_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    affinity_partitioner& _Part);

Parameterwaarden

_Index_type
Het type index dat wordt gebruikt voor de iteratie.

_Functie
Het type van de functie die tijdens elke iteratie wordt uitgevoerd.

_Partitioner
Het type partitioneerfunctie dat wordt gebruikt om het opgegeven bereik te partitioneren.

eerste
De eerste index die moet worden opgenomen in de iteratie.

laatste
De index één voorbij de laatste index die in de iteratie moet worden opgenomen.

_Stap
De waarde waarmee moet worden gestapt bij het herhalen van first naar last. De stap moet positief zijn. invalid_argument wordt gegenereerd als de stap kleiner is dan 1.

_Func
De functie die moet worden uitgevoerd bij elke iteratie. Dit kan een lambda-expressie, een functiepointer of een object zijn dat een versie van de operator voor functieoproep ondersteunt met de handtekening void operator()(_Index_type).

_Deel
Een verwijzing naar het partitionerobject. Het argument kan een van constauto_partitioner&, conststatic_partitioner&, constsimple_partitioner& of affinity_partitioner& zijn als een affinity_partitioner-object wordt gebruikt, moet de verwijzing een verwijzing naar niet-const l-waarde zijn, zodat het algoritme de status kan opslaan voor toekomstige lussen die opnieuw moeten worden gebruikt.

Opmerkingen

Zie Parallelle algoritmenvoor meer informatie.

parallel_for_each

parallel_for_each past een opgegeven functie toe op elk element binnen een bereik, parallel. Het is semantisch equivalent aan de for_each functie in de std naamruimte, behalve dat iteratie over de elementen parallel wordt uitgevoerd en de volgorde van iteratie niet is opgegeven. Het argument _Func moet een operator voor functieaanroep van het formulier ondersteunen operator()(T) waarbij de parameter T het itemtype is van de container die wordt overschreven.

template <typename _Iterator, typename _Function>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func);

template <typename _Iterator, typename _Function, typename _Partitioner>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func,
    _Partitioner&& _Part);

Parameterwaarden

_Iterator
Het type iterator dat wordt gebruikt om de container te herhalen.

_Functie
Het type van de functie dat wordt toegepast op elk element binnen het bereik.

_Partitioner
eerste
Een iterator die de positie van het eerste element aanpakt die in parallelle iteratie moet worden opgenomen.

laatste
Een iterator die de positie na het laatste element aanpakt die in parallelle iteratie moet worden opgenomen.

_Func
Een door de gebruiker gedefinieerd functieobject dat wordt toegepast op elk element in het bereik.

Opmerkingen

auto_partitioner wordt gebruikt voor de overbelasting zonder een expliciete partitioner.

Voor iterators die geen willekeurige toegang ondersteunen, wordt alleen auto_partitioner ondersteund.

Zie Parallelle algoritmenvoor meer informatie.

parallel_invoke

Hiermee worden de functieobjecten uitgevoerd die parallel als parameters worden opgegeven en worden geblokkeerd totdat ze zijn uitgevoerd. Elk functieobject kan een lambda-expressie, een aanwijzer naar functie zijn of een object dat de operator voor functieoproep ondersteunt met de handtekening void operator()().

template <typename _Function1, typename _Function2>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2);

template <typename _Function1, typename _Function2, typename _Function3>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9,
    typename _Function10>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9,
    const _Function10& _Func10);

Parameterwaarden

_Function1
Het type van het eerste functieobject dat parallel moet worden uitgevoerd.

_Function2
Het type van het tweede functieobject dat parallel moet worden uitgevoerd.

_Function3
Het type van het derde functieobject dat parallel moet worden uitgevoerd.

_Function4
Het type van het vierde functieobject dat parallel moet worden uitgevoerd.

_Function5
Het type van het vijfde functieobject dat parallel moet worden uitgevoerd.

_Function6
Het type van het zesde functieobject dat parallel moet worden uitgevoerd.

_Function7
Het type van het zevende functieobject dat parallel moet worden uitgevoerd.

_Function8
Het type van het achtste functieobject dat parallel moet worden uitgevoerd.

_Function9
Het type van het negende functieobject dat parallel moet worden uitgevoerd.

_Function10
Het type van het tiende functieobject dat parallel moet worden uitgevoerd.

_Func1
Het eerste functieobject dat parallel moet worden uitgevoerd.

_Func2
Het tweede functieobject dat parallel moet worden uitgevoerd.

_Func3
Het derde functieobject dat parallel moet worden uitgevoerd.

_Func4
Het vierde functieobject dat parallel moet worden uitgevoerd.

_Func5
Het vijfde functieobject dat parallel moet worden uitgevoerd.

_Func6
Het zesde functieobject dat parallel moet worden uitgevoerd.

_Func7
Het zevende functieobject dat parallel moet worden uitgevoerd.

_Func8
Het achtste functieobject dat parallel moet worden uitgevoerd.

_Func9
Het negende functieobject dat parallel moet worden uitgevoerd.

_Func10
Het tiende functieobject dat parallel moet worden uitgevoerd.

Opmerkingen

Houd er rekening mee dat een of meer van de functieobjecten die als parameters worden geleverd, inline kunnen worden uitgevoerd op de aanroepende context.

Als een of meer van de functieobjecten die als parameters aan deze functie worden doorgegeven, een uitzondering genereert, selecteert de runtime een dergelijke uitzondering van het kiezen en doorgeven van deze uit de aanroep naar parallel_invoke.

Zie Parallelle algoritmenvoor meer informatie.

parallel_radixsort

Rangschikt elementen in een opgegeven bereik in een niet-aflopende volgorde met behulp van een radix sorteeralgoritmen. Dit is een stabiele sorteerfunctie die een projectiefunctie vereist waarmee elementen kunnen worden gesorteerd in niet-ondertekende sleutels die op gehele getallen lijken. Standaard initialisatie is vereist voor de elementen die worden gesorteerd.

template<typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator, typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator, typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

Parameterwaarden

_Random_iterator
Het iteratortype van het invoerbereik.

_Allocator
Het type C++-standaardbibliotheek dat compatibel is met geheugentoewijzing.

_Functie
Het type projectiefunctie.

_Beginnen
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden gesorteerd.

_Einde
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om te worden gesorteerd.

_Alloc
Een exemplaar van een C++-standaardbibliotheek die compatibel is met geheugentoewijzing.

_Proj_func
Een door de gebruiker gedefinieerd projectiefunctieobject dat een element converteert naar een integrale waarde.

_Chunk_size
De mimimumgrootte van een segment dat in tweeën wordt gesplitst voor parallelle uitvoering.

Opmerkingen

Voor alle overbelastingen is n * sizeof(T) extra ruimte vereist, waarbij n het aantal elementen is dat moet worden gesorteerd en T het elementtype is. Een unaire projectie-functor met de handtekening I _Proj_func(T) is vereist om een sleutel te retourneren wanneer een element wordt gegeven, waarbij T het elementtype is en I een niet-ondertekend geheel getal is.

Als u geen projectiefunctie opgeeft, wordt een standaardprojectiefunctie gebruikt die eenvoudigweg het element retourneert voor integrale typen. De functie kan niet worden gecompileerd als het element geen integraal type is bij afwezigheid van een projectiefunctie.

Als u geen allocatortype of instantie opgeeft, wordt de C++ Standard Library Memory Allocator std::allocator<T> gebruikt om de buffer toe te wijzen.

parallel_reduce

Berekent de som van alle elementen in een opgegeven bereik door opeenvolgende gedeeltelijke sommen te berekenen of berekent het resultaat van opeenvolgende gedeeltelijke resultaten, vergelijkbaar met het gebruik van een opgegeven binaire bewerking dan som, parallel. parallel_reduce is semantisch vergelijkbaar met std::accumulate, behalve dat de binaire bewerking moet worden gekoppeld en een identiteitswaarde vereist in plaats van een initiële waarde.

template<typename _Forward_iterator>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity);

template<typename _Forward_iterator, typename _Sym_reduce_fun>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity,
    _Sym_reduce_fun _Sym_fun);

template<typename _Reduce_type,
    typename _Forward_iterator,
    typename _Range_reduce_fun,
    typename _Sym_reduce_fun>
inline _Reduce_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const _Reduce_type& _Identity,
    const _Range_reduce_fun& _Range_fun,
    const _Sym_reduce_fun& _Sym_fun);

Parameterwaarden

_Forward_iterator
Het type iterator van het invoerbereik.

_Sym_reduce_fun
Het type van de symmetrische reductiefunctie. Dit moet een functietype zijn met handtekening _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), waarbij _Reduce_type hetzelfde is als het identiteitstype en het resultaattype van de reductie. Voor de derde overbelasting moet dit consistent zijn met het uitvoertype van _Range_reduce_fun.

_Reduce_type
Het type dat de invoer vermindert, wat kan afwijken van het type invoerelement. De retourwaarde en identiteitswaarde hebben dit type.

_Range_reduce_fun
Het type bereikreductiefunctie. Dit moet een functietype zijn met handtekening _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type hetzelfde is als het identiteitstype en het resultaattype van de reductie.

_Beginnen
Een invoer-iterator die het eerste element in het bereik aanpakt om te worden verminderd.

_Einde
Een invoer-iterator die het element aanpakt dat zich één positie boven het laatste element in het bereik bevindt om te worden verminderd.

_Identiteit
De identiteitswaarde _Identity is van hetzelfde type als het resultaattype van de vermindering en ook de value_type van de iterator voor de eerste en tweede overbelasting. Voor de derde overbelasting moet de identiteitswaarde hetzelfde type hebben als het resultaattype van de reductie, maar kan verschillen van de value_type van de iterator. Het moet een geschikte waarde hebben, zodat de operator voor bereikreductie _Range_fun, wanneer deze wordt toegepast op een bereik van één element van het type value_type en de identiteitswaarde, zich gedraagt als een type cast van de waarde van het type value_type tot het identiteitstype.

_Sym_fun
De symmetrische functie die wordt gebruikt in de tweede van de reductie. Raadpleeg Opmerkingen voor meer informatie.

_Range_fun
De functie die in de eerste fase van de reductie wordt gebruikt. Raadpleeg Opmerkingen voor meer informatie.

Retourwaarde

Het resultaat van de reductie.

Opmerkingen

Om een parallelle reductie uit te voeren, verdeelt de functie het bereik in segmenten op basis van het aantal werkrollen dat beschikbaar is voor de onderliggende planner. De reductie vindt plaats in twee fasen, de eerste fase voert een vermindering uit binnen elk segment en de tweede fase voert een vermindering uit tussen de gedeeltelijke resultaten van elk segment.

De eerste overbelasting vereist dat de value_typevan de iterator, T, hetzelfde zijn als het identiteitswaardetype en het resultaattype voor reductie. Het elementtype T moet de operator T T::operator + (T) opgeven om elementen in elk segment te verminderen. Dezelfde operator wordt ook gebruikt in de tweede fase.

De tweede overbelasting vereist ook dat de value_type van de iterator hetzelfde is als het identiteitswaardetype en het resultaattype voor reductie. De opgegeven binaire operator _Sym_fun wordt gebruikt in beide reductiefasen, waarbij de identiteitswaarde als de initiële waarde voor de eerste fase wordt gebruikt.

Voor de derde overbelasting moet het type identiteitswaarde hetzelfde zijn als het resultaattype voor vermindering, maar de value_type van de iterator kan afwijken van beide. De bereikreductiefunctie _Range_fun wordt gebruikt in de eerste fase met de identiteitswaarde als de initiële waarde en de binaire functie _Sym_reduce_fun wordt toegepast op subresultaten in de tweede fase.

parallel_sort

template<typename _Random_iterator>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,typename _Function>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Parameterwaarden

_Random_iterator
Het iteratortype van het invoerbereik.

_Functie
Het type van de functor voor binaire vergelijking.

_Beginnen
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden gesorteerd.

_Einde
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om te worden gesorteerd.

_Chunk_size
De minimale grootte van een segment dat in tweeën wordt gesplitst voor parallelle uitvoering.

Opmerkingen

De eerste overbelasting maakt gebruik van de binaire comparator std::less.

De tweede overbelaste maakt gebruik van de opgegeven binaire comparator die de handtekening moet hebben bool _Func(T, T) waarbij T het type van de elementen in het invoerbereik is.

parallel_transform

Hiermee past u een opgegeven functieobject toe op elk element in een bronbereik of op een paar elementen uit twee bronbereiken en kopieert u de retourwaarden van het functieobject parallel naar een doelbereik. Deze functionaliteit is semantisch gelijk aan std::transform.

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const static_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const simple_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    affinity_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator,
    typename _Partitioner>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op,
    _Partitioner&& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op);

Parameterwaarden

_Input_iterator1
Het type van de eerste of enige invoer-iterator.

_Output_iterator
Het type uitvoer-iterator.

_Unary_operator
Het type unaire functor dat moet worden uitgevoerd op elk element in het invoerbereik.

_Input_iterator2
Het type tweede invoer-iterator.

_Binary_operator
Het type binaire functor dat met twee elementen uit de twee bronbereiken is uitgevoerd, wordt gekoppeld aan elementen.

_Partitioner
eerste1
Een invoer-iterator die de positie van het eerste element in het eerste of enige bronbereik aangeeft waarop moet worden uitgevoerd.

laatste
Een invoer-iterator die de positie na het laatste element in het eerste of alleen bronbereik aangeeft waarop moet worden uitgevoerd.

_Resultaat
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanpakt.

_Unary_op
Een door de gebruiker gedefinieerd unaire functieobject dat wordt toegepast op elk element in het bronbereik.

eerste2
Een invoer-iterator die de positie van het eerste element in het tweede bronbereik aangeeft waarop moet worden bediend.

_Binary_op
Een door de gebruiker gedefinieerd binair functieobject dat in een voorwaartse volgorde wordt toegepast op de twee bronbereiken.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het doelbereik aanspreekt dat de uitvoerelementen ontvangt die zijn getransformeerd door het functieobject.

Opmerkingen

auto_partitioner wordt gebruikt voor de overbelastingen zonder een expliciet partitionerargument.

Voor iterators die geen willekeurige toegang ondersteunen, wordt alleen auto_partitioner ondersteund.

De overbelastingen die het argument gebruiken _Unary_op het invoerbereik omzetten in het uitvoerbereik door de unaire functor toe te passen op elk element in het invoerbereik. _Unary_op moet de operator voor functieaanroep ondersteunen met handtekening operator()(T) waarbij T het waardetype is van het bereik dat wordt ge curseerd.

De overbelastingen die het argument nemen _Binary_op twee invoerbereiken omzetten in het uitvoerbereik door de binaire functor toe te passen op één element uit het eerste invoerbereik en één element uit het tweede invoerbereik. _Binary_op moet de operator voor functieoproep ondersteunen met handtekening operator()(T, U) waarbij T, U waardetypen zijn van de twee invoer-iterators.

Zie Parallelle algoritmenvoor meer informatie.

ontvangen

Een algemene ontvangst-implementatie, waardoor een context kan wachten op gegevens uit precies één bron en de waarden kan filteren die worden geaccepteerd.

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

Parameterwaarden

T-
Het nettoladingstype.

_Src
Een aanwijzer of verwijzing naar de bron waaruit gegevens worden verwacht.

_Timeout
De maximale tijd waarvoor de methode voor de gegevens moet worden gebruikt, in milliseconden.

_Filter_proc
Een filterfunctie die bepaalt of berichten moeten worden geaccepteerd.

Retourwaarde

Een waarde uit de bron, van het nettoladingstype.

Opmerkingen

Als de parameter _Timeout een andere waarde heeft dan de constante COOPERATIVE_TIMEOUT_INFINITE, wordt de uitzondering operation_timed_out gegenereerd als de opgegeven hoeveelheid tijd verloopt voordat een bericht wordt ontvangen. Als u een time-out met een lengte nul wilt, moet u de functie try_receive gebruiken in plaats van receive aan te roepen met een time-out van 0 (nul), omdat deze efficiënter is en geen uitzonderingen genereert voor time-outs.

Zie Message Passing Functionsvoor meer informatie.

run_with_cancellation_token

Hiermee wordt een functieobject onmiddellijk en synchroon uitgevoerd in de context van een bepaald annuleringstoken.

template<typename _Function>
void run_with_cancellation_token(
    const _Function& _Func,
    cancellation_token _Ct);

Parameterwaarden

_Functie
Het type van het functieobject dat wordt aangeroepen.

_Func
Het functieobject dat wordt uitgevoerd. Dit object moet de operator voor functieoproep ondersteunen met een handtekening van void(void).

_Ct
Het annuleringstoken waarmee impliciete annulering van het functieobject wordt gecontroleerd. Gebruik cancellation_token::none() als u wilt dat de functie wordt uitgevoerd zonder dat impliciete annulering van een bovenliggende taakgroep wordt geannuleerd.

Opmerkingen

Onderbrekingspunten in het functieobject worden geactiveerd wanneer de cancellation_token wordt geannuleerd. Het expliciete token _Ct isoleert deze _Func van bovenliggende annulering als het bovenliggende token een ander token of geen token heeft.

Verzenden

Een synchrone verzendbewerking, die wacht totdat het doel het bericht accepteert of weigert.

template <class T>
bool send(_Inout_ ITarget<T>* _Trg, const T& _Data);

template <class T>
bool send(ITarget<T>& _Trg, const T& _Data);

Parameterwaarden

T-
Het nettoladingstype.

_Trg
Een aanwijzer of verwijzing naar het doel waarnaar gegevens worden verzonden.

_Gegevens
Een verwijzing naar de gegevens die moeten worden verzonden.

Retourwaarde

true als het bericht is geaccepteerd, false anders.

Opmerkingen

Zie Message Passing Functionsvoor meer informatie.

set_ambient_scheduler

inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);

Parameterwaarden

_Scheduler
De omgevingsplanner die moet worden ingesteld.

set_task_execution_resources

Hiermee beperkt u de uitvoeringsbronnen die worden gebruikt door de interne werkrolthreads van Concurrency Runtime tot de opgegeven affiniteitsset.

Het is alleen geldig om deze methode aan te roepen voordat de Resource Manager is gemaakt of tussen twee Levensduur van Resource Manager. Deze kan meerdere keren worden aangeroepen zolang de Resource Manager niet bestaat op het moment van aanroepen. Nadat een affiniteitslimiet is ingesteld, blijft deze van kracht totdat de volgende geldige aanroep van de methode set_task_execution_resources.

Het opgegeven affiniteitsmasker hoeft geen subset van het procesaffiniteitsmasker te zijn. De procesaffiniteit wordt indien nodig bijgewerkt.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

void __cdecl set_task_execution_resources(
    unsigned short count,
    PGROUP_AFFINITY _PGroupAffinity);

Parameterwaarden

_ProcessAffinityMask
Het affiniteitsmasker waartoe de gelijktijdigheidsruntimewerkthreads moeten worden beperkt. Gebruik deze methode alleen op een systeem met meer dan 64 hardwarethreads als u de Gelijktijdigheidsruntime wilt beperken tot een subset van de huidige processorgroep. Over het algemeen moet u de versie van de methode gebruiken die een matrix van groepsaffiniteit accepteert als parameter, om affiniteit op computers met meer dan 64 hardwarethreads te beperken.

aantal
Het aantal GROUP_AFFINITY vermeldingen in de matrix die is opgegeven door de parameter _PGroupAffinity.

_PGroupAffinity
Een matrix met GROUP_AFFINITY vermeldingen.

Opmerkingen

De methode genereert een invalid_operation uitzondering als een Resource Manager aanwezig is op het moment dat deze wordt aangeroepen en een invalid_argument uitzondering als de opgegeven affiniteit resulteert in een lege set resources.

De versie van de methode die een matrix van groepsaffiniteit als parameter gebruikt, mag alleen worden gebruikt op besturingssystemen met versie Windows 7 of hoger. Anders wordt er een invalid_operation uitzondering gegenereerd.

Als u de procesaffiniteit programmatisch wijzigt nadat deze methode is aangeroepen, wordt de affiniteit van Resource Manager niet opnieuw geëvalueerd. Daarom moeten alle wijzigingen in procesaffiniteit worden aangebracht voordat u deze methode aanroept.

ruilen

Hiermee worden de elementen van twee concurrent_vector objecten uitgewisseld.

template<typename T, class _Ax>
inline void swap(
    concurrent_vector<T, _Ax>& _A,
    concurrent_vector<T, _Ax>& _B);

Parameterwaarden

T-
Het gegevenstype van de elementen die zijn opgeslagen in de gelijktijdige vectoren.

_Bijl
Het type allocator van de gelijktijdige vectoren.

_Een
De gelijktijdige vector waarvan de elementen moeten worden uitgewisseld met die van de gelijktijdige vector _B.

_B
De gelijktijdige vector die de elementen levert die moeten worden gewisseld, of de vector waarvan de elementen moeten worden uitgewisseld met die van de gelijktijdige vector _A.

Opmerkingen

De sjabloonfunctie is een algoritme dat is gespecialiseerd in de containerklasse concurrent_vector om de lidfunctie uit te voeren _A. concurrent_vector::swap(_B). Dit zijn exemplaren van de gedeeltelijke volgorde van functiesjablonen door de compiler. Wanneer sjabloonfuncties zodanig overbelast zijn dat de overeenkomst van de sjabloon met de functie-aanroep niet uniek is, selecteert de compiler de meest gespecialiseerde versie van de sjabloonfunctie. De algemene versie van de sjabloonfunctie, template <class T> void swap(T&, T&), in de algoritmeklasse werkt op basis van toewijzing en is een trage bewerking. De gespecialiseerde versie in elke container is veel sneller omdat deze kan werken met de interne weergave van de containerklasse.

Deze methode is niet gelijktijdigheidsveilig. U moet ervoor zorgen dat er geen andere threads bewerkingen uitvoeren op een van de gelijktijdige vectoren wanneer u deze methode aanroept.

task_from_exception

template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(
    _ExType _Exception,
    const task_options& _TaskOptions = task_options());

Parameterwaarden

_TaskType

_ExType

_Uitzondering

_TaskOptions

Retourwaarde

task_from_result

template<typename T>
task<T> task_from_result(
    T _Param,
    const task_options& _TaskOptions = task_options());

inline task<bool> task_from_result(ool _Param);

inline task<void> task_from_result(
    const task_options& _TaskOptions = task_options());

Parameterwaarden

T-

_Param

_TaskOptions

Retourwaarde

Trace_agents_register_name

Koppelt de opgegeven naam aan het berichtblok of de agent in de ETW-trace.

template <class T>
void Trace_agents_register_name(
    _Inout_ T* _PObject,
    _In_z_ const wchar_t* _Name);

Parameterwaarden

T-
Het type object. Dit is meestal een berichtblok of een agent.

_PObject
Een aanwijzer naar het berichtblok of de agent die in de tracering wordt genoemd.

_Naam
De naam voor het opgegeven object.

try_receive

Een algemene implementatie voor try-receive, waardoor een context kan zoeken naar gegevens uit precies één bron en de waarden kan filteren die worden geaccepteerd. Als de gegevens niet gereed zijn, retourneert de methode false.

template <class T>
bool try_receive(_Inout_ ISource<T>* _Src, T& _value);

template <class T>
bool try_receive(
    _Inout_ ISource<T>* _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

template <class T>
bool try_receive(ISource<T>& _Src, T& _value);

template <class T>
bool try_receive(
    ISource<T>& _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

Parameterwaarden

T-
Het nettoladingstype

_Src
Een aanwijzer of verwijzing naar de bron waaruit gegevens worden verwacht.

_waarde
Een verwijzing naar een locatie waar het resultaat wordt geplaatst.

_Filter_proc
Een filterfunctie die bepaalt of berichten moeten worden geaccepteerd.

Retourwaarde

Een bool waarde die aangeeft of er al dan niet een nettolading is geplaatst in _value.

Opmerkingen

Zie Message Passing Functionsvoor meer informatie.

wachten

Hiermee wordt de huidige context gedurende een opgegeven hoeveelheid tijd onderbroken.

void __cdecl wait(unsigned int _Milliseconds);

Parameterwaarden

_Milliseconden
Het aantal milliseconden waarvoor de huidige context moet worden onderbroken. Als de parameter _Milliseconds is ingesteld op de waarde 0, moet de huidige context uitvoering opleveren naar andere uitvoerbare contexten voordat u doorgaat.

Opmerkingen

Als deze methode wordt aangeroepen in een runtimeplannercontext voor gelijktijdigheid, vindt de scheduler een andere context die moet worden uitgevoerd op de onderliggende resource. Omdat de scheduler van aard is, kan deze context niet exact na het opgegeven aantal milliseconden worden hervat. Als de planner bezig is met het uitvoeren van andere taken die niet samenwerken aan de planner, kan de wachttijd voor onbepaalde tijd zijn.

when_all

Hiermee maakt u een taak die met succes wordt voltooid wanneer alle taken die als argumenten zijn opgegeven, zijn voltooid.

template <typename _Iterator>
auto when_all(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options()) ->
    decltype (details::_WhenAllImpl<typename std::iterator_traits<_Iterator>::value_type::result_type,
    _Iterator>::_Perform(_TaskOptions, _Begin,  _End));

Parameterwaarden

_Iterator
Het type invoer-iterator.

_Beginnen
De positie van het eerste element in het bereik van elementen dat moet worden gecombineerd tot de resulterende taak.

_Einde
De positie van het eerste element buiten het bereik van elementen dat in de resulterende taak moet worden gecombineerd.

_TaskOptions
Het task_options-object.

Retourwaarde

Een taak die is voltooid wanneer alle invoertaken zijn voltooid. Als de invoertaken van het type Tzijn, is de uitvoer van deze functie een task<std::vector<T>>. Als de invoertaken van het type void is de uitvoertaak ook een task<void>.

Opmerkingen

when_all is een niet-blokkerende functie die als resultaat een task produceert. In tegenstelling tot taak::wait, is het veilig om deze functie aan te roepen in een UWP-app op de ASTA-thread (Application STA).

Als een van de taken wordt geannuleerd of een uitzondering genereert, wordt de geretourneerde taak vroeg voltooid, in de geannuleerde status en wordt de uitzondering, als deze plaatsvindt, gegenereerd als u taak aanroept::get of task::wait voor die taak.

Zie taakparallellismevoor meer informatie.

when_any

Hiermee maakt u een taak die met succes wordt voltooid wanneer een van de taken die als argumenten zijn opgegeven, is voltooid.

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options())
    -> decltype (
        details::_WhenAnyImpl<
            typename std::iterator_traits<_Iterator>::value_type::result_type,
            _Iterator>::_Perform(_TaskOptions, _Begin, _End));

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    cancellation_token _CancellationToken)
       -> decltype (
           details::_WhenAnyImpl<
               typename std::iterator_traits<_Iterator>::value_type::result_type,
               _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End));

Parameterwaarden

_Iterator
Het type invoer-iterator.

_Beginnen
De positie van het eerste element in het bereik van elementen dat moet worden gecombineerd tot de resulterende taak.

_Einde
De positie van het eerste element buiten het bereik van elementen dat in de resulterende taak moet worden gecombineerd.

_TaskOptions
_CancellationToken
Het annuleringstoken waarmee de annulering van de geretourneerde taak wordt gecontroleerd. Als u geen annuleringstoken opgeeft, ontvangt de resulterende taak het annuleringstoken van de taak die ervoor zorgt dat deze wordt voltooid.

Retourwaarde

Een taak die is voltooid wanneer een van de invoertaken is voltooid. Als de invoertaken van het type Tzijn, is de uitvoer van deze functie een task<std::pair<T, size_t>>>, waarbij het eerste element van het paar het resultaat is van de voltooiingstaak en het tweede element de index is van de taak die is voltooid. Als de invoertaken van het type void de uitvoer een task<size_t>is, waarbij het resultaat de index is van de voltooiingstaak.

Opmerkingen

when_any is een niet-blokkerende functie die als resultaat een task produceert. In tegenstelling tot taak::wait, is het veilig om deze functie aan te roepen in een UWP-app op de ASTA-thread (Application STA).

Zie taakparallellismevoor meer informatie.

Zie ook

naamruimte voor gelijktijdigheid

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-07

Delen via

Naamruimtefuncties voor gelijktijdigheid

Alloc

Parameterwaarden

Retourwaarde

Opmerkingen

asend

Parameterwaarden

Retourwaarde

Opmerkingen

cancel_current_task

duidelijk

Parameterwaarden

create_async

Parameterwaarden

Retourwaarde

Opmerkingen

CreateResourceManager

Retourwaarde

Opmerkingen

create_task

Parameterwaarden

Retourwaarde

Opmerkingen

DisableTracing

Retourwaarde

EnableTracing

Retourwaarde

Vrij

Parameterwaarden

Opmerkingen

get_ambient_scheduler

Retourwaarde

GetExecutionContextId

Retourwaarde

Opmerkingen

GetOSVersion

Retourwaarde

Opmerkingen

GetProcessorCount

Retourwaarde

Opmerkingen

GetProcessorNodeCount

Retourwaarde

Opmerkingen

GetSchedulerId

Retourwaarde

Opmerkingen

internal_assign_iterators

Parameterwaarden

interruption_point

Opmerkingen

is_current_task_group_canceling

Retourwaarde

Opmerkingen

make_choice

Parameterwaarden

Retourwaarde

make_greedy_join

Parameterwaarden

Retourwaarde

make_join

Parameterwaarden

Retourwaarde

make_task

Parameterwaarden

Retourwaarde

Opmerkingen

parallel_buffered_sort

Parameterwaarden

Opmerkingen

parallel_for

Parameterwaarden

Opmerkingen

parallel_for_each

Parameterwaarden

Opmerkingen

parallel_invoke

Parameterwaarden

Opmerkingen