concurrency-Namespace-Funktionen

Artikel
10/12/2023

Alloc

Reserviert einen Speicherblock mit der in der Unterbelegungsfunktion für die Zwischenspeicherung der Concurrency Runtime angegebenen Größe.

void* __cdecl Alloc(size_t _NumBytes);

Parameter

_Numbytes
Die Anzahl der zuzuweisenden Bytes des Arbeitsspeichers.

Rückgabewert

Ein Zeiger auf neu zugewiesenen Speicher.

Hinweise

Weitere Informationen dazu, welche Szenarien in Ihrer Anwendung von der Verwendung des Zwischenspeichern-Unterspeicherns profitieren könnten, finden Sie unter Task Scheduler.

asend

Ein asynchroner Sendevorgang, der eine Aufgabe zum Weitergeben der Daten an den Zielblock plant.

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

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

Parameter

T
Der Typ der zu sendenden Daten.

_Trg
Ein Zeiger oder Ein Verweis auf das Ziel, an das Daten gesendet werden.

_Daten
Ein Verweis auf die zu sendenden Daten.

Rückgabewert

true wenn die Nachricht vor der Rückgabe der Methode akzeptiert wurde, false andernfalls.

Hinweise

Weitere Informationen finden Sie unter Message Passing Functions.

cancel_current_task

Bricht die gerade ausgeführte Aufgabe ab. Diese Funktion kann aus dem Text einer Aufgabe aufgerufen werden, um die Ausführung der Aufgabe abzubrechen und ihn dabei in den canceled Zustand übergehen zu lassen.

Der Aufruf dieser Funktion, wenn Sie sich nicht innerhalb des Texts von einem task befinden, ist kein unterstütztes Szenario. Dies führt zu einem nicht definierten Verhalten, z. B. zu einem Absturz oder zu nicht reagierender Reaktion in Ihrer Anwendung.

inline __declspec(noreturn) void __cdecl cancel_current_task();

clear

Löscht die gleichzeitige Warteschlange und zerstört alle derzeit enqueuierten Elemente. Diese Methode ist nicht nebenläufigkeitssicher.

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

Parameter

_Ax

create_async

Erstellt ein asynchrones Konstrukt der Windows Runtime auf einem vom Benutzer angegebenes Lambda oder Funktionsobjekt. Der Rückgabetyp von create_async ist entweder IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ oder IAsyncOperationWithProgress<TResult, TProgress>^ auf Grundlage der Signatur des Lambda-Ausdrucks, der an die Methode übergeben wurde.

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

Parameter

_Funktion
Art:

_Func
Der Lambda-Ausdruck oder das Funktionsobjekt, aus dem ein asynchrones Windows-Runtime-Konstrukt erstellt werden soll.

Rückgabewert

Ein asynchrones Konstrukt, dargestellt durch ein IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, oder ein IAsyncOperationWithProgress<TResult, TProgress>^. Die Schnittstelle, die zurückgegeben wird, hängt von der Signatur des Lambda-Ausdrucks ab, der an die Funktion übergeben wird.

Hinweise

Der Rückgabetyp des Lambdaausdrucks bestimmt, ob das Konstrukt eine Aktion oder ein Vorgang ist.

Lambda-Ausdrücke, die "void" zurückgeben, führen zur Erstellung von Aktionen. Lambda-Ausdrücke, die ein Ergebnis vom Typ TResult zurückgeben, führen zur Erstellung von TResult-Vorgängen.

Der Lambda-Ausdruck kann auch task<TResult> zurückgeben, was die asynchronen Abläufe kapselt, oder die Fortsetzung einer Kette von Aufgaben ist, die die asynchronen Abläufe darstellen. In diesem Fall wird der Lambda-Ausdruck selbst inline ausgeführt, da die Aufgaben asynchron ausgeführt werden, und der Rückgabetyp des Lambda-Ausdrucks wird entpackt, um das von create_async zurückgegebene asynchrone Konstrukt zu erstellen. Dies bedeutet, dass eine Lambda-Funktion, die eine Aufgabe<zurückgibt> , die Erstellung von Aktionen verursacht, und eine Lambda-Funktion, die ein Aufgaben-TResult<zurückgibt, die Erstellung von Vorgängen von TResult> verursacht.

Der Lambda-Ausdruck akzeptiert null, ein oder zwei Argumente. Die gültigen Argumente sind progress_reporter<TProgress> und cancellation_token in dieser Reihenfolge, wenn beide verwendet werden. Ein Lambda-Ausdruck ohne Argumente bewirkt die Erstellung eines asynchronen Konstrukts ohne die Möglichkeit der Statusberichterstellung. Eine Lambda-Funktion, die einen progress_reporter<TProgress> akzeptiert, führt create_async dazu, dass ein asynchrones Konstrukt zurückgegeben wird, das den Fortschritt des Typs "TProgress" jedes Mal meldet, wenn die report Methode des progress_reporter Objekts aufgerufen wird. Ein Lambda-Ausdruck, der ein „cancellation_token“ verwendet, kann dieses Token verwenden, um auf einen Abbruch zu prüfen, oder es an Aufgaben übergeben, die er erstellt, sodass ein Abbruch des asynchronen Konstrukts den Abbruch dieser Aufgaben verursacht.

Wenn der Textkörper des Lambda- oder Funktionsobjekts ein Ergebnis (und nicht ein Aufgaben-TResult<>) zurückgibt, wird die Lamdba im Kontext einer Aufgabe, die von der Runtime implizit für sie erstellt wird, asynchron innerhalb des Prozesses MTA ausgeführt. Die IAsyncInfo::Cancel-Methode verursacht den Abbruch der impliziten Aufgabe.

Wenn der Text des Lambda-Ausdrucks eine Aufgabe zurückgibt, wird der Lambda-Ausdruck inline ausgeführt. Durch Deklarieren des Lambda-Ausdrucks zur Verwendung eines Arguments des Typs cancellation_token können Sie den Abbruch aller Aufgaben auslösen, die Sie innerhalb des Lambda-Ausdrucks erstellen, indem Sie dieses Token bei ihrer Erstellung übergeben. Sie können auch die register_callback-Methode im Token verwenden, um die Laufzeit zu veranlassen, einen Rückruf aufzurufen, wenn Sie IAsyncInfo::Cancel für den asynchronen Vorgang oder die verursachte Aktion aufrufen.

Diese Funktion ist nur für Windows-Runtime Apps verfügbar.

CreateResourceManager

Gibt eine Schnittstelle zurück, die die Singletoninstanz des Ressourcen-Managers der Concurrency Runtime darstellt. Der Ressourcen-Manager ist für das Zuweisen von Ressourcen für Planer, die miteinander kooperieren möchten, zuständig.

IResourceManager* __cdecl CreateResourceManager();

Rückgabewert

Eine IResourceManager-Schnittstelle.

Hinweise

Mehrere nachfolgende Aufrufe dieser Methode geben die gleiche Instanz des Ressourcen-Managers zurück. Jeder Aufruf der Methode erhöht eine Verweisanzahl für den Ressourcen-Manager und muss mit einem Aufruf der IResourceManager::Release-Methode abgeglichen werden, wenn der Zeitplan mit dem Ressourcen-Manager kommuniziert.

unsupported_os wird ausgelöst, wenn das Betriebssystem von der Parallelitäts-Runtime nicht unterstützt wird.

create_task

Erstellt ein PPL-Aufgabenobjekt. Das Element create_task kann überall dort verwendet werden, wo Sie einen Aufgabenkonstruktor verwendet hätten. Es wird hauptsächlich der Einfachheit halber bereitgestellt, da es beim Erstellen eines Tasks die Verwendung des auto-Schlüsselwort ermöglicht.

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

Parameter

T
Der Typ des Parameters, von dem die Aufgabe erstellt werden soll.

_ReturnType
Art:

_Param
Der Parameter, von dem der Task erstellt werden soll. Dies kann ein Lambda- oder Funktionsobjekt, ein task_completion_event Objekt, ein anderes task Objekt oder eine Windows::Foundation::IAsyncInfo-Schnittstelle sein, wenn Sie Aufgaben in Ihrer UWP-App verwenden.

_TaskOptions
Die Vorgangsoptionen.

_Aufgabe
Der zu erstellende Task.

Rückgabewert

Eine neue Aufgabe des Typs T, der von _Param abgeleitet wird.

Hinweise

Die erste Überladung verhält sich wie ein Aufgabenkonstruktor, der einen einzelnen Parameter akzeptiert.

Die zweite Überladung weist das Abbruchtoken, das der neu erstellten Aufgabe bereitgestellt wird, zu. Wenn Sie diese Überladung verwenden, ist die Übergabe eines anderen task-Objekts als erster Parameter nicht zulässig.

Der Typ des zurückgegebenen Tasks wird vom ersten Parameter zur Funktion abgeleitet. Wenn _Param ein task_completion_event<T>, ein task<T> oder ein Funktionselement ist, das entweder den Typ T oder task<T> zurückgibt, ist der Typ des erstellten Tasks task<T>.

Wenn es sich in einer UWP-App _Param um den Typ "Windows::Foundation::IAsyncOperation<T>^" oder "Windows::Foundation::IAsyncOperationWithProgress<T,P>^" oder einen Functor handelt, der einen dieser Typen zurückgibt, ist die erstellte Aufgabe vom Typ .task<T> Ist _Param der Typ Windows::Foundation::IAsyncAction^ oder Windows::Foundation::IAsyncActionWithProgress<P>^, oder ein Functor, der einen dieser Typen zurückgibt, weist die erstellte Aufgabe den Typ auf task<void>.

DisableTracing

Deaktiviert die Ablaufverfolgung in der Concurrency Runtime. Diese Funktion ist veraltet, da die Registrierung der ETW-Ablaufverfolgung standardmäßig aufgehoben wird.

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

Rückgabewert

Wenn die Ablaufverfolgung ordnungsgemäß deaktiviert wurde, S_OK wird sie zurückgegeben. Wenn die Ablaufverfolgung noch nicht initiiert wurde, E_NOT_STARTED wird sie zurückgegeben.

EnableTracing

Aktiviert die Ablaufverfolgung in der Concurrency Runtime. Diese Funktion ist veraltet, da die Registrierung der ETW-Ablaufverfolgung jetzt standardmäßig erfolgt.

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

Rückgabewert

Wenn die Ablaufverfolgung ordnungsgemäß initiiert wurde, S_OK wird sie zurückgegeben. Andernfalls E_NOT_STARTED wird die Ablaufverfolgung zurückgegeben.

Kostenlos

Gibt einen Speicherblock frei, der zuvor mit der Alloc-Methode der Unterbelegungsfunktion für die Zwischenspeicherung der Concurrency Runtime reserviert wurde.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parameter

_PAllocation
Ein Zeiger auf den Arbeitsspeicher, der zuvor mit der Alloc-Methode reserviert wurde und jetzt freigegeben werden soll. Wenn der _PAllocation-Parameter auf den Wert NULL festgelegt wurde, ignoriert diese Methode den Parameter und kehrt sofort zurück.

Hinweise

Weitere Informationen dazu, welche Szenarien in Ihrer Anwendung von der Verwendung des Zwischenspeichern-Unterspeicherns profitieren könnten, finden Sie unter Task Scheduler.

get_ambient_scheduler

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

Rückgabewert

GetExecutionContextId

Gibt einen eindeutigen Bezeichner zurück, der einem Ausführungskontext zugewiesen werden kann, der die IExecutionContext-Schnittstelle implementiert.

unsigned int __cdecl GetExecutionContextId();

Rückgabewert

Ein eindeutiger Bezeichner für einen Ausführungskontext.

Hinweise

Verwenden Sie diese Methode, um einen Bezeichner für Den Ausführungskontext abzurufen, bevor Sie eine IExecutionContext Schnittstelle als Parameter an eine der methoden übergeben, die vom Ressourcen-Manager angeboten werden.

GetOSVersion

Gibt die Betriebssystemversion zurück.

IResourceManager::OSVersion __cdecl GetOSVersion();

Rückgabewert

Ein Enumerationswert, der das Betriebssystem darstellt.

Hinweise

unsupported_os wird ausgelöst, wenn das Betriebssystem von der Parallelitäts-Runtime nicht unterstützt wird.

GetProcessorCount

Gibt die Anzahl von Hardwarethreads des zugrunde liegenden Systems zurück.

unsigned int __cdecl GetProcessorCount();

Rückgabewert

Die Anzahl der Hardwarethreads.

Hinweise

unsupported_os wird ausgelöst, wenn das Betriebssystem von der Parallelitäts-Runtime nicht unterstützt wird.

GetProcessorNodeCount

Gibt die Anzahl von NUMA-Knoten oder Prozessorpaketen des zugrunde liegenden Systems zurück.

unsigned int __cdecl GetProcessorNodeCount();

Rückgabewert

Die Anzahl von NUMA-Knoten oder Prozessorpaketen.

Hinweise

Wenn das System mehr NUMA-Knoten als Prozessorpakete enthält, wird die Anzahl der NUMA-Knoten zurückgegeben. Andernfalls wird die Anzahl der Prozessorpakete zurückgegeben.

unsupported_os wird ausgelöst, wenn das Betriebssystem von der Parallelitäts-Runtime nicht unterstützt wird.

GetSchedulerId

Gibt einen eindeutigen Bezeichner zurück, der einem Planer zugewiesen werden kann, der die IScheduler-Schnittstelle implementiert.

unsigned int __cdecl GetSchedulerId();

Rückgabewert

Ein eindeutiger Bezeichner für einen Scheduler.

Hinweise

Verwenden Sie diese Methode, um einen Bezeichner für Den Zeitplan abzurufen, bevor Sie eine IScheduler Schnittstelle als Parameter an eine der methoden übergeben, die vom Ressourcen-Manager angeboten werden.

internal_assign_iterators

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

Parameter

_Ax

first

last

interruption_point

Erstellt einen Unterbrechungspunkt für den Abbruch. Wenn ein Abbruch im Kontext, in dem diese Funktion aufgerufen wird, ausgeführt wird, löst diese eine interne Ausnahme aus, mit der die Ausführung der aktuell ausgeführten parallelen Verarbeitung abgebrochen wird. Wenn kein Abbruch ausgeführt wird, bleibt die Funktion untätig.

inline void interruption_point();

Hinweise

Sie sollten die interne Abbruch exception, die von der interruption_point() Funktion ausgelöst wird, nicht abfangen. Die Ausnahme wird von der Laufzeit abgefangen und behandelt, und das Abfangen kann dazu führen, dass sich Ihr Programm ungewöhnlich verhält.

is_current_task_group_canceling

Gibt zurück, ob die Aufgabengruppe, die gerade inline auf dem aktuellen Kontext ausgeführt wird, in diesem Moment (oder in Kürze) einen Abbruch durchführt. Beachten Sie, dass false zurückgegeben wird, wenn auf dem aktuellen Kontext zurzeit inline keine Aufgabengruppe ausgeführt wird.

bool __cdecl is_current_task_group_canceling();

Rückgabewert

true wenn die derzeit ausgeführte Aufgabengruppe abbricht, false andernfalls.

Hinweise

Weitere Informationen finden Sie unter "Stornierung".

make_choice

Erstellt einen choice-Meldungsblock aus einem optionalen Scheduler oder einer ScheduleGroup und mindestens zwei Eingabequellen.

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

Parameter

T1
Der Meldungsblocktyp der ersten Quelle.

T2
Der Meldungsblocktyp der zweiten Quelle.

_PScheduler
Das Scheduler -Objekt, in dem die Weiterleitungsaufgabe für den choice -Meldungsblock geplant ist.

_Item1
Die erste Quelle.

_Item2
Die zweite Quelle.

_Artikel
Zusätzliche Quellen.

_PScheduleGroup
Das ScheduleGroup -Objekt, in dem die Weiterleitungsaufgabe für den choice -Meldungsblock geplant ist. Das verwendete Scheduler -Objekt wird von der Planungsgruppe impliziert.

Rückgabewert

Ein choice-Nachrichtenblock mit zwei oder mehr Eingabequellen.

make_greedy_join

Erstellt einen greedy multitype_join-Meldungsblock aus einem optionalen Scheduler oder einer ScheduleGroup und mindestens zwei Eingabequellen.

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

Parameter

T1
Der Meldungsblocktyp der ersten Quelle.

T2
Der Meldungsblocktyp der zweiten Quelle.

_PScheduler
Das Scheduler -Objekt, in dem die Weiterleitungsaufgabe für den multitype_join -Meldungsblock geplant ist.

_Item1
Die erste Quelle.

_Item2
Die zweite Quelle.

_Artikel
Zusätzliche Quellen.

_PScheduleGroup
Das ScheduleGroup -Objekt, in dem die Weiterleitungsaufgabe für den multitype_join -Meldungsblock geplant ist. Das verwendete Scheduler -Objekt wird von der Planungsgruppe impliziert.

Rückgabewert

Ein greedy multitype_join-Nachrichtenblock mit zwei oder mehr Eingabequellen.

make_join

Erstellt einen non_greedy multitype_join-Meldungsblock aus einem optionalen Scheduler oder einer ScheduleGroup und mindestens zwei Eingabequellen.

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

Parameter

T1
Der Meldungsblocktyp der ersten Quelle.

T2
Der Meldungsblocktyp der zweiten Quelle.

_PScheduler
Das Scheduler -Objekt, in dem die Weiterleitungsaufgabe für den multitype_join -Meldungsblock geplant ist.

_Item1
Die erste Quelle.

_Item2
Die zweite Quelle.

_Artikel
Zusätzliche Quellen.

Rückgabewert

Ein non_greedy multitype_join-Nachrichtenblock mit zwei oder mehr Eingabequellen.

make_task

Eine Factorymethode zum Erstellen eines task_handle-Objekts.

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

Parameter

_Funktion
Der Typ des Funktionsobjekts, das aufgerufen wird, um die durch das task_handle Objekt dargestellte Arbeit auszuführen.

_Func
Die Funktion, die aufgerufen wird, um die durch das task_handle Objekt dargestellte Arbeit auszuführen. Dies kann ein Lambda-Functor, ein Zeiger auf eine Funktion oder ein Objekt sein, das eine Version des Funktionsaufrufoperators mit der Signatur void operator()()unterstützt.

Rückgabewert

Ein task_handle-Objekt.

Hinweise

Diese Funktion ist nützlich, wenn Sie ein task_handle Objekt mit einem Lambda-Ausdruck erstellen müssen, da es Ihnen ermöglicht, das Objekt zu erstellen, ohne den wahren Typ des Lambda-Functors zu kennen.

parallel_buffered_sort

Ordnet die Elemente in einem angegebenen Bereich in einer nicht absteigenden Reihenfolge oder nach einem durch ein binäres Prädikat angegebenen Sortierkriterium parallel an. Diese Funktion entspricht std::sort semantisch darin, dass sie eine vergleichsbasierte, instabile, direkte Sortierung ist, abgesehen von den zusätzlich erforderlichen O(n)-Leerzeichen und er notwendigen Standardinitialisierung für die sortierten Elemente.

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

Parameter

_Random_iterator
Der Iteratortyp des Eingabebereichs.

_Zuweisung
Der Typ eines mit der C++-Standardbibliothek kompatiblen Speicherzuordnungsservers.

_Funktion
Der Typ des binären Vergleichszeichens.

_Beginnen
Ein zufälliger Eingabeiterator, der die Position des ersten Elements in dem Bereich adressiert, der sortiert werden soll.

_Ende
Ein zufälliger Eingabeiterator, der die Position des ersten Elements direkt hinter dem letzten Element in dem Bereich adressiert, der sortiert werden soll.

_Alloc
Eine Instanz eines mit der C++-Standardbibliothek kompatiblen Speicherzuordnungsservers.

_Func
Ein benutzerdefiniertes Prädikatfunktionsobjekt, das das Vergleichskriterium definiert, das durch aufeinander folgende Elemente in der Sortierung erfüllt werden soll. Ein binäres Prädikat akzeptiert zwei Argumente und gibt bei Erfüllung true und bei Nichterfüllung false zurück. Diese Vergleichoperatorfunktion muss eine strikte schwache Sortierung auf Elementenpaare der Sequenz anwenden.

_Chunk_size
Die Mimimumgröße eines Datenblocks, der zur parallelen Ausführung in zwei unterteilt wird.

Hinweise

Alle Überladungen erfordern n * sizeof(T) zusätzlichen Platz, wobei n die Anzahl der zu sortierenden Elemente und T der Elementtyp ist. In den meisten Fällen zeigt parallel_buffered_sort eine Leistungsverbesserung gegenüber parallel_sort an, und Sie sollten sie über parallel_sort verwenden, wenn der Arbeitsspeicher verfügbar ist.

Wenn Sie keinen binären Vergleich std::less angeben, wird als Standard verwendet, der den Elementtyp zum Bereitstellen des Operators operator<()erfordert.

Wenn Sie keinen Allocatortyp oder eine Instanz angeben, wird der C++-Standardbibliotheksspeicher-Allocator std::allocator<T> verwendet, um den Puffer zuzuweisen.

Der Algorithmus dividiert den Eingabebereich in zwei Blöcke und teilt die einzelnen Blöcke für die Ausführung parallel in zwei Teilabschnitte auf. Das optionale Argument _Chunk_size kann verwendet werden, um für den Algorithmus anzugeben, dass er Blöcke der Größe <_Chunk_size fortlaufend behandelt.

Parallel_for

parallel_for durchläuft einen Bereich von Indizes und führt bei jeder Iteration parallel eine vom Benutzer bereitgestellte Funktion aus.

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

Parameter

_Index_type
Der Typ des Indexes, der für die Iteration verwendet wird.

_Funktion
Der Typ der Funktion, die bei jeder Iteration ausgeführt wird.

_Partitionierer
Der Typ des Partitionierers, der zum Partitionieren des angegebenen Bereichs verwendet wird.

first
Der erste Index, der in die Iteration einbezogen werden soll.

last
Der Index, der über den letzten Index hinaus in die Iteration aufgenommen werden soll.

_Schritt
Der Wert, um den beim Durchlaufen von first zu lastSchritt ausgeführt werden soll. Der Schritt muss positiv sein. invalid_argument wird ausgelöst, wenn der Schritt kleiner als 1 ist.

_Func
Die Funktion, die bei jeder Iteration ausgeführt werden soll. Dies kann ein Lambda-Ausdruck, ein Funktionszeiger oder ein beliebiges Objekt sein, das eine Version des Funktionsaufrufoperators mit der Signatur void operator()(_Index_type)unterstützt.

_Teil
Ein Verweis auf das Partitionerobjekt. Das Argument kann eine von constauto_partitioner&,const static_partitioner&,const simple_partitioner& oder affinity_partitioner& Sein, wenn ein affinity_partitioner-Objekt verwendet wird, muss der Verweis ein Nicht-Const l-Wert-Bezug sein, sodass der Algorithmus den Zustand für zukünftige Schleifen speichern kann, um sie wieder zu verwenden.

Hinweise

Weitere Informationen finden Sie unter parallele Algorithmen.

Parallel_for_each

parallel_for_each wendet eine angegebene Funktion parallel auf jedes Element innerhalb eines Bereichs an. Sie entspricht semantisch der for_each-Funktion im std-Namespace, außer dass die Iteration über die Elemente parallel ausgeführt wird und die Reihenfolge der Iteration nicht angegeben ist. Das Argument _Func muss einen Funktionsaufrufoperator in der Form operator()(T) unterstützen, wobei der Parameter T der Elementtyp des durchlaufenen Containers ist.

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

Parameter

_Iterator
Der Typ des Iterators, der zum Durchlaufen des Containers verwendet wird.

_Funktion
Der Typ der Funktion, die auf jedes Element innerhalb des Bereichs angewendet wird.

_Partitionierer
first
Ein Iterator, der die Position des ersten Elements angibt, das in parallele Iteration eingeschlossen werden soll.

last
Ein Iterator, der die Position eins hinter dem endgültigen Element angibt, das in parallele Iteration eingeschlossen werden soll.

_Func
Ein benutzerdefiniertes Funktionsobjekt, das auf jedes Element im Bereich angewendet wird.

Hinweise

auto_partitioner wird für die Überladung ohne explizite Partitionierung verwendet.

Für Iteratoren, die den zufälligen Zugriff nicht unterstützen, wird nur auto_partitioner unterstützt.

Weitere Informationen finden Sie unter parallele Algorithmen.

Parallel_invoke

Führt die als Parameter angegebenen Funktionsobjekte parallel aus, und blockiert, bis die Ausführung beendet ist. Jedes Funktionsobjekt kann ein Lambdaausdruck, ein Zeiger auf eine Funktion oder ein anderes Objekt sein, das den Funktionsaufrufoperator mit der Signatur void operator()() unterstützt.

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

Parameter

_Function1
Der Typ des ersten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function2
Der Typ des zweiten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function3
Der Typ des dritten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function4
Der Typ des vierten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function5
Der Typ des fünften Funktionsobjekts, das parallel ausgeführt werden soll.

_Function6
Der Typ des sechsten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function7
Der Typ des siebten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function8
Der Typ des achten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function9
Der Typ des neunten Funktionsobjekts, das parallel ausgeführt werden soll.

_Function10
Der Typ des zehnten Funktionsobjekts, das parallel ausgeführt werden soll.

_Func1
Das erste Funktionsobjekt, das parallel ausgeführt werden soll.

_Func2
Das zweite Funktionsobjekt, das parallel ausgeführt werden soll.

_Func3
Das dritte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func4
Das vierte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func5
Das fünfte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func6
Das sechste Funktionsobjekt, das parallel ausgeführt werden soll.

_Func7
Das siebte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func8
Das achte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func9
Das neunte Funktionsobjekt, das parallel ausgeführt werden soll.

_Func10
Das zehnte Funktionsobjekt, das parallel ausgeführt werden soll.

Hinweise

Beachten Sie, dass mindestens eines der Funktionsobjekte, die als Parameter bereitgestellt werden, inline im aufrufenden Kontext ausgeführt werden kann.

Wenn mindestens eines der Funktionsobjekte, die als Parameter an diese Funktion übergeben werden, eine Ausnahme auslöst, wählt die Laufzeit eine solche Ausnahme der Auswahl aus und verteilt sie aus dem Aufruf an parallel_invoke.

Weitere Informationen finden Sie unter parallele Algorithmen.

parallel_radixsort

Ordnet Elemente in einem angegebenen Bereich mithilfe eines Basis-Sortieralgorithmus in einer absteigenden Reihenfolge an. Dies ist eine stabile Sortierfunktion, die eine Projektionsfunktion erfordert, mit der Elemente zur Sortierung in Schlüssel, die ganzen Zahlen ohne Vorzeichen ähneln, projiziert werden können. Standardinitialisierung ist für die zu sortierenden Elemente erforderlich.

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

Parameter

_Random_iterator
Der Iteratortyp des Eingabebereichs.

_Zuweisung
Der Typ eines mit der C++-Standardbibliothek kompatiblen Speicherzuordnungsservers.

_Funktion
Der Typ der Projektionsfunktion.

_Beginnen
Ein zufälliger Eingabeiterator, der die Position des ersten Elements in dem Bereich adressiert, der sortiert werden soll.

_Ende
Ein zufälliger Eingabeiterator, der die Position des ersten Elements direkt hinter dem letzten Element in dem Bereich adressiert, der sortiert werden soll.

_Alloc
Eine Instanz eines mit der C++-Standardbibliothek kompatiblen Speicherzuordnungsservers.

_Proj_func
Ein benutzerdefiniertes Projektionsfunktionsobjekt, das ein Element in einen integralen Wert konvertiert.

_Chunk_size
Die Mimimumgröße eines Datenblocks, der zur parallelen Ausführung in zwei unterteilt wird.

Hinweise

Alle Überladungen erfordern n * sizeof(T) zusätzlichen Platz, wobei n die Anzahl der zu sortierenden Elemente und T der Elementtyp ist. Ein unärer Projektions-Functor mit der Signatur I _Proj_func(T) ist erforderlich, um einen Schlüssel zurückzugeben, wenn ein Element angegeben wird, wobei T der Elementtyp und I ein nicht signierter ganzzahliger Typ ist.

Wenn Sie keine Projektionsfunktion bereitstellen, wird eine Standardprojektionsfunktion, die einfach das Element zurückgibt, für integrale Typen verwendet. Die Funktion kann nicht kompiliert werden, wenn das Element kein integraler Typ ist, wenn keine Projektionsfunktion vorhanden ist.

Wenn Sie keinen Allocatortyp oder eine Instanz angeben, wird der C++-Standardbibliotheksspeicher-Allocator std::allocator<T> verwendet, um den Puffer zuzuweisen.

parallel_reduce

Berechnet die Summe aller Elemente in einem angegebenen Bereich, indem aufeinander folgende Teilsummen berechnet werden, oder berechnet das Ergebnis der aufeinander folgenden Teilergebnisse, die auf ähnliche Weise mithilfe eines angegebenen binären Vorgangs (außer Summe) abgerufen werden parallel. parallel_reduce entspricht std::accumulate semantisch, außer dass der binäre Vorgang assoziativ sein muss und ein Identitätswert anstelle eines Anfangswerts erforderlich ist.

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

Parameter

_Forward_iterator
Der Iteratortyp des Eingabebereichs.

_Sym_reduce_fun
Der Typ der symmetrischen Reduktionsfunktion. Dies muss ein Funktionstyp mit Signatur _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type)sein, wobei _Reduce_type mit dem Identitätstyp und dem Ergebnistyp der Reduzierung identisch ist. Für die dritte Überladung sollte dies mit dem Ausgabetyp übereinstimmen _Range_reduce_fun.

_Reduce_type
Der Typ, auf den die Eingabe reduziert wird, was sich vom Eingabeelementtyp unterscheiden kann. Der Rückgabewert und der Identitätswert weist diesen Typ auf.

_Range_reduce_fun
Der Typ der Bereichsreduzierungsfunktion. Dies muss ein Funktionstyp mit Signatur _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type)sein, _Reduce_type identisch mit dem Identitätstyp und dem Ergebnistyp der Reduktion ist.

_Beginnen
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um reduziert zu werden.

_Ende
Ein Eingabe-Iterator, der das Element adressiert, das eine Position über das endgültige Element im Bereich hinausgibt, um reduziert zu werden.

_Identität
Der Identitätswert _Identity ist vom gleichen Typ wie der Ergebnistyp der Reduktion und auch der value_type Iterator für die erste und zweite Überladung. Für die dritte Überladung muss der Identitätswert denselben Typ wie der Ergebnistyp der Reduktion aufweisen, kann jedoch vom value_type Iterator abweichen. Er muss einen geeigneten Wert aufweisen, damit sich der Bereichsreduktionsoperator _Range_funverhält, wenn er auf einen Bereich eines einzelnen Typelements value_type und den Identitätswert angewendet wird, wie ein Typ vom Typ value_type in den Identitätstyp.

_Sym_fun
Die symmetrische Funktion, die im zweiten Teil der Reduktion verwendet wird. Weitere Informationen finden Sie in den Anmerkungen.

_Range_fun
Die Funktion, die in der ersten Phase der Reduktion verwendet wird. Weitere Informationen finden Sie in den Anmerkungen.

Rückgabewert

Das Ergebnis der Reduktion.

Hinweise

Um eine parallele Reduzierung durchzuführen, teilt die Funktion den Bereich auf der Grundlage der Anzahl der für den zugrunde liegenden Planer verfügbaren Mitarbeiter in Blöcke auf. Die Reduktion erfolgt in zwei Phasen, die erste Phase führt eine Reduktion innerhalb jedes Abschnitts durch, und die zweite Phase führt eine Reduktion zwischen den Teilergebnissen der einzelnen Blöcke durch.

Für die erste Überladung muss der Iterator value_typeT, derSelbe wie der Identitätswerttyp sowie der Ergebnistyp zur Reduzierung sein. Der Elementtyp T muss den Operator T T::operator + (T) bereitstellen, um Elemente in jedem Block zu reduzieren. Derselbe Operator wird auch in der zweiten Phase verwendet.

Die zweite Überladung erfordert außerdem, dass der Iterator value_type mit dem Identitätswerttyp und dem Ergebnistyp zur Reduzierung identisch ist. Der angegebene binäre Operator _Sym_fun wird in beiden Reduktionsphasen verwendet, wobei der Identitätswert als Anfangswert für die erste Phase verwendet wird.

Für die dritte Überladung muss der Identitätswerttyp mit dem Ergebnistyp der Reduzierung identisch sein, der Iterator value_type kann sich jedoch von beiden unterscheiden. Die Bereichsreduzierungsfunktion _Range_fun wird in der ersten Phase mit dem Identitätswert als Anfangswert verwendet, und die binäre Funktion _Sym_reduce_fun wird in der zweiten Phase auf Subergebnisse angewendet.

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

Parameter

_Random_iterator
Der Iteratortyp des Eingabebereichs.

_Funktion
Der Typ des Binären Vergleichs-Functors.

_Beginnen
Ein zufälliger Eingabeiterator, der die Position des ersten Elements in dem Bereich adressiert, der sortiert werden soll.

_Ende
Ein zufälliger Eingabeiterator, der die Position des ersten Elements direkt hinter dem letzten Element in dem Bereich adressiert, der sortiert werden soll.

_Chunk_size
Die Mindestgröße eines Datenblocks, der für die parallele Ausführung in zwei unterteilt wird.

Hinweise

Die erste Überladung verwendet den binären Vergleich.std::less

Die zweite überladene Verwendet den bereitgestellten binären Vergleichsator, der die Signatur bool _Func(T, T) aufweisen sollte, wobei T der Typ der Elemente im Eingabebereich ist.

parallel_transform

Wendet ein angegebenes Funktionsobjekt auf jedes Element in einem Quellbereich oder auf ein Elementpaar aus zwei Quellbereichen an und kopiert die Rückgabewerte des Funktionsobjekts parallel in einen Zielbereich. Diese Funktion entspricht semantisch 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);

Parameter

_Input_iterator1
Der Typ des ersten oder einzigen Eingabe-Iterators.

_Output_iterator
Der Typ des Ausgabeiterators.

_Unary_operator
Der Typ des unären Functors, der für jedes Element im Eingabebereich ausgeführt werden soll.

_Input_iterator2
Der Typ des zweiten Eingabe-Iterators.

_Binary_operator
Der Typ des binären Functors, der paarweise für Elemente aus den beiden Quellbereichen ausgeführt wird.

_Partitionierer
first1
Ein Eingabe-Iterator, der die Position des ersten Elements im ersten oder einzigen Quellbereich adressiert, auf dem ausgeführt werden soll.

letzte 1
Ein Eingabe-Iterator, der die Position eins hinter dem endgültigen Element im ersten oder einzigen Quellbereich angibt, an dem ausgeführt werden soll.

_Ergebnis
Ein Ausgabeiterator, der die Position des ersten Elements im Zielbereich adressiert.

_Unary_op
Ein benutzerdefiniertes unäres Funktionsobjekt, das auf jedes Element im Quellbereich angewendet wird.

First2
Ein Eingabeiterator, der die Position des ersten Elements im zweiten Quellbereich adressiert.

_Binary_op
Ein benutzerdefiniertes binäres Funktionsobjekt, das in einer Vorwärtsreihenfolge auf die beiden Quellbereiche gekoppelt angewendet wird.

Rückgabewert

Ein Ausgabeiterator, der die Position direkt hinter dem letzten Element im Zielbereich adressiert, der die vom Funktionsobjekt umgewandelten Ausgabeelemente erhält.

Hinweise

auto_partitioner werden für die Überladungen ohne explizites Partitionierargument verwendet.

Für Iteratoren, die den zufälligen Zugriff nicht unterstützen, wird nur auto_partitioner unterstützt.

Die Überladungen, die das Argument _Unary_op übernehmen, transformieren den Eingabebereich in den Ausgabebereich, indem der unäre Functor auf jedes Element im Eingabebereich angewendet wird. _Unary_op muss den Funktionsaufrufoperator mit Signatur operator()(T) unterstützen, wobei T es sich um den Werttyp des Bereichs handelt, der durchlaufen wird.

Die Überladungen, die das Argument _Binary_op verwenden, transformieren zwei Eingabebereiche in den Ausgabebereich, indem der binäre Functor auf ein Element aus dem ersten Eingabebereich und ein Element aus dem zweiten Eingabebereich angewendet wird. _Binary_op muss den Funktionsaufrufoperator mit Signatur operator()(T, U) unterstützen, wobei Tes U sich bei den Werttypen der beiden Eingabe iteratoren handelt.

Weitere Informationen finden Sie unter parallele Algorithmen.

receive

Eine allgemeine Empfangsimplementierung, mit der ein Kontext auf Daten von genau einer Quelle warten und die akzeptierten Werte filtern kann.

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

Parameter

T
Der Nutzlasttyp.

_Src
Ein Zeiger oder Ein Verweis auf die Quelle, aus der Daten erwartet werden.

_Timeout
Die maximale Zeit, für die die Methode für die Daten in Millisekunden verwendet werden soll.

_Filter_proc
Eine Filterfunktion, die bestimmt, ob Nachrichten akzeptiert werden sollen.

Rückgabewert

Ein Wert aus der Quelle des Nutzlasttyps.

Hinweise

Wenn der Parameter _Timeout einen anderen Wert als die Konstante COOPERATIVE_TIMEOUT_INFINITEaufweist, wird die Ausnahme ausgelöst, operation_timed_out ausgelöst wird, wenn die angegebene Zeitspanne abläuft, bevor eine Nachricht empfangen wird. Wenn Sie ein Timeout der Länge Null benötigen, sollten Sie die try_receive-Funktion anstelle eines Timeouts von 0 (Null) verwenden, receive da es effizienter ist und keine Ausnahmen für Timeouts auslöst.

Weitere Informationen finden Sie unter Message Passing Functions.

run_with_cancellation_token

Führt sofort synchron ein Funktionsobjekt im Kontext eines angegebenen Abbruchtokens aus.

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

Parameter

_Funktion
Der Typ des Funktionsobjekts, das aufgerufen wird.

_Func
Das Funktionsobjekt, das ausgeführt wird. Dieses Objekt muss den Funktionsaufrufoperator mit einer Signatur von void(void) unterstützen.

_Ct
Das Abbruchtoken, das den impliziten Abbruch des Funktionsobjekts steuert. Verwenden Sie cancellation_token::none() diese Option, wenn die Funktion ohne die Möglichkeit einer impliziten Abbruchfunktion einer übergeordneten Aufgabengruppe ausgeführt werden soll.

Hinweise

Unterbrechungspunkte im Funktionsobjekt werden ausgelöst, wenn der cancellation_token Vorgang abgebrochen wird. Das explizite Token _Ct isoliert dies _Func vom übergeordneten Abbruch, wenn das übergeordnete Element über ein anderes Token oder kein Token verfügt.

Send

Ein synchroner Sendevorgang, der wartet, bis das Ziel die Meldung akzeptiert oder ablehnt.

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

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

Parameter

T
Der Nutzlasttyp.

_Trg
Ein Zeiger oder Ein Verweis auf das Ziel, an das Daten gesendet werden.

_Daten
Ein Verweis auf die zu sendenden Daten.

Rückgabewert

true wenn die Nachricht akzeptiert wurde, false andernfalls.

Hinweise

Weitere Informationen finden Sie unter Message Passing Functions.

set_ambient_scheduler

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

Parameter

_Scheduler
Der festzulegende Umgebungsplaner.

set_task_execution_resources

Schränkt die Ausführungsressourcen, die von den internen Arbeitsthreads der Concurrency Runtime verwendet werden, auf den angegebenen Affinitätssatz ein.

Es ist nur gültig, diese Methode vor Erstellung des Ressourcen-Managers oder zwischen der Lebensdauer zweier Ressourcen-Manager aufzurufen. Sie kann mehrmals aufgerufen werden, solange der Ressourcen-Manager zum Zeitpunkt des Aufrufs nicht vorhanden ist. Nachdem eine Affinitätsgrenze eingerichtet wurde, bleibt diese bis zum nächsten gültigen Aufruf der set_task_execution_resources-Methode bestehen.

Die bereitgestellte Affinitätsmaske muss keine Teilmenge der Prozessaffinitätsmaske sein. Die Prozessaffinität wird bei Bedarf aktualisiert.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Parameter

_ProcessAffinityMask
Die Affinitätsmaske, auf die die Concurrency Runtime-Arbeitsthreads beschränkt werden sollen. Verwenden Sie diese Methode für ein System mit mehr als 64 Hardwarethreads nur, wenn Sie die Parallelitätslaufzeit auf eine Teilmenge der aktuellen Prozessorgruppe beschränken möchten. Im Allgemeinen sollten Sie die Version der Methode verwenden, die ein Array von Gruppenaffinitäten als Parameter akzeptiert, um die Affinität auf Computern mit mehr als 64 Hardwarethreads einzuschränken.

count
Die Anzahl der GROUP_AFFINITY Einträge in dem array, das durch den Parameter _PGroupAffinityangegeben wird.

_PGroupAffinity
Ein Array von GROUP_AFFINITY Einträgen.

Hinweise

Die Methode löst eine invalid_operation Ausnahme aus, wenn ein Ressourcen-Manager zum Zeitpunkt des Aufrufs vorhanden ist, und eine invalid_argument Ausnahme, wenn die angegebene Affinität zu einer leeren Gruppe von Ressourcen führt.

Die Version der Methode, die ein Array von Gruppenaffinitäten als Parameter verwendet, sollte nur auf Betriebssystemen mit Version Windows 7 oder höher verwendet werden. Andernfalls wird eine invalid_operation Ausnahme ausgelöst.

Das programmgesteuerte Ändern der Prozessaffinität, nachdem diese Methode aufgerufen wurde, führt nicht dazu, dass der Ressourcen-Manager die Affinität erneut auswertet, auf die sie beschränkt ist. Daher sollten alle Änderungen an der Prozessaffinität vorgenommen werden, bevor diese Methode aufgerufen wird.

swap

Tauscht die Elemente zweier concurrent_vector-Objekte.

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

Parameter

T
Der Datentyp der elemente, die in den gleichzeitigen Vektoren gespeichert sind.

_Ax
Der Zuweisungstyp der gleichzeitigen Vektoren.

_Eine
Der gleichzeitige Vektor, dessen Elemente mit denen des gleichzeitigen Vektors _Bausgetauscht werden sollen.

_B
Der gleichzeitige Vektor, der die zu tauschenden Elemente oder den Vektor bereitstellt, dessen Elemente mit denen des gleichzeitigen Vektors _Aausgetauscht werden sollen.

Hinweise

Die Vorlagenfunktion ist ein Algorithmus, der auf die Containerklasse concurrent_vector spezialisiert ist, um die Memberfunktion _Aauszuführen. concurrent_vector::swap( _B). Hierbei handelt es sich um Instanzen der partiellen Sortierung von Funktionsvorlagen durch den Compiler. Wenn Vorlagenfunktionen so überladen werden, dass die Übereinstimmung der Vorlage mit dem Funktionsaufruf nicht eindeutig ist, wählt der Compiler die spezialisierteste Version der Vorlagenfunktion aus. Die allgemeine Version der Vorlagenfunktion, template <class T> void swap(T&, T&)in der Algorithmusklasse funktioniert nach Zuordnung und ist ein langsamer Vorgang. Die spezialisierte Version in jedem Container ist viel schneller, da sie mit der internen Darstellung der Containerklasse genutzt werden kann.

Diese Methode ist nicht nebenläufigkeitssicher. Sie müssen sicherstellen, dass keine anderen Threads Vorgänge für einen der gleichzeitigen Vektoren ausführen, wenn Sie diese Methode aufrufen.

task_from_exception

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

Parameter

_TaskType

_ExType

_Ausnahme

_TaskOptions

Rückgabewert

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());

Parameter

_Param

_TaskOptions

Rückgabewert

Trace_agents_register_name

Ordnet den angegebenen Namen dem Nachrichtenblock oder dem Agent in der ETW-Ablaufverfolgung zu.

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

Parameter

T
Der Typ des Objekts. Dies ist in der Regel ein Nachrichtenblock oder ein Agent.

_PObject
Ein Zeiger auf den Nachrichtenblock oder Agent, der in der Ablaufverfolgung benannt wird.

_Namen
Der Name für das angegebene Objekt.

try_receive

Eine allgemeine try-receive-Implementierung, mit der ein Kontext Daten von genau einer Quelle suchen und die akzeptierten Werte filtern kann. Wenn die Daten nicht bereit sind, wird die Methode zurückgegeben 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);

Parameter

T
Der Nutzlasttyp

_Src
Ein Zeiger oder Ein Verweis auf die Quelle, aus der Daten erwartet werden.

_Wert
Ein Verweis auf einen Ort, an dem das Ergebnis platziert wird.

_Filter_proc
Eine Filterfunktion, die bestimmt, ob Nachrichten akzeptiert werden sollen.

Rückgabewert

Ein bool Wert, der angibt, ob eine Nutzlast eingefügt _valuewurde.

Hinweise

Weitere Informationen finden Sie unter Message Passing Functions.

wait

Hält den aktuellen Kontext für eine bestimmte Zeit an.

void __cdecl wait(unsigned int _Milliseconds);

Parameter

_Millisekunden
Die Anzahl der Millisekunden, für die der aktuelle Kontext angehalten werden soll. Wenn der _Milliseconds Parameter auf den Wert 0festgelegt ist, sollte der aktuelle Kontext die Ausführung für andere runnable Kontexte liefern, bevor der Vorgang fortgesetzt wird.

Hinweise

Wenn diese Methode für einen Concurrency Runtime-Schedulerkontext aufgerufen wird, findet der Scheduler einen anderen Kontext, der für die zugrunde liegende Ressource ausgeführt werden soll. Da der Zeitplan kooperativ ist, kann dieser Kontext nicht genau nach der angegebenen Anzahl von Millisekunden fortgesetzt werden. Wenn der Zeitplan beschäftigt ist, andere Vorgänge auszuführen, die nicht kooperativ zum Planer führen, kann der Wartezeit unbegrenzt sein.

when_all

Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn alle als Argumente angegeben Aufgaben erfolgreich abgeschlossen werden.

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

Parameter

_Iterator
Der Typ des Eingabeiterators.

_Beginnen
Die Position des ersten Elements in dem Bereich von Elementen, die mit der resultierenden Aufgabe kombiniert werden sollen.

_Ende
Die Position des ersten Elements hinter dem Bereich von Elementen, die mit der resultierenden Aufgabe kombiniert werden sollen.

_TaskOptions
Das task_options-Objekt.

Rückgabewert

Eine Aufgabe, die erfolgreich abgeschlossen wird, wenn alle Eingabeaufgaben erfolgreich abgeschlossen wurden. Wenn die Eingabeaufgaben vom Typ T sind, wird die Ausgabe dieser Funktion task<std::vector<T>> sein. Wenn die Eingabeaufgaben vom Typ void sind, ist die Ausgabeaufgabe auch task<void>.

Hinweise

when_all ist eine nicht blockierende Funktion, die task als Ergebnis erzeugt. Im Gegensatz zu task::wait ist es sicher, diese Funktion in einer UWP-App im ASTA -Thread (Application STA) aufzurufen.

Wenn eine der Aufgaben abgebrochen oder eine Ausnahme ausgelöst wird, wird die zurückgegebene Aufgabe frühzeitig abgeschlossen, im abgebrochenen Zustand und die Ausnahme wird ausgelöst, wenn sie "task::get" oder task::wait in diesem Vorgang aufruft.

Weitere Informationen finden Sie unter Task Parallelism.

when_any

Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn eine der als Argumente angegeben Aufgaben erfolgreich abgeschlossen wird.

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

Parameter

_Iterator
Der Typ des Eingabeiterators.

_Beginnen
Die Position des ersten Elements in dem Bereich von Elementen, die mit der resultierenden Aufgabe kombiniert werden sollen.

_Ende
Die Position des ersten Elements hinter dem Bereich von Elementen, die mit der resultierenden Aufgabe kombiniert werden sollen.

_TaskOptions
_Cancellationtoken
Das Abbruchtoken, das den Abbruch der zurückgegebenen Aufgabe steuert. Wenn Sie kein Abbruchtoken bereitstellen, erhält die resultierende Aufgabe das Abbruchtoken der Aufgabe, die ihren Abschluss verursacht.

Rückgabewert

Eine Aufgabe, die erfolgreich abgeschlossen ist, wenn eine der Eingabeaufgaben erfolgreich abgeschlossen wurde. Wenn die Eingabeaufgaben vom Typ T sind, ist die Ausgabe dieser Funktion task<std::pair<T, size_t>>>, wobei das erste Element des Paares das Ergebnis der letzten Aufgabe ist, und das zweite Element der Index der beendeten Aufgabe. Wenn die Eingabeaufgaben vom Typ void sind, ist die Ausgabe task<size_t>, wobei das Ergebnis der Index der abgeschlossenen Aufgabe ist.

Hinweise

when_any ist eine nicht blockierende Funktion, die task als Ergebnis erzeugt. Im Gegensatz zu task::wait ist es sicher, diese Funktion in einer UWP-App im ASTA -Thread (Application STA) aufzurufen.

Weitere Informationen finden Sie unter Task Parallelism.

Siehe auch

Concurrency-Namespace