concurrency – funkce oboru názvů
Alloc
asend
cancel_current_task
clear
create_async
create_task
CreateResourceManager
DisableTracing
EnableTracing
Free
get_ambient_scheduler
GetExecutionContextId
GetOSVersion
GetProcessorCount
GetProcessorNodeCount
Aloka
Přidělí blok paměti velikosti zadané z dílčího přidělení mezipaměti Concurrency Runtime.
void* __cdecl Alloc(size_t _NumBytes);
Parametry
_NumBytes
Počet bajtů paměti, které se mají přidělit.
Návratová hodnota
Ukazatel na nově přidělenou paměť.
Poznámky
Další informace o tom, které scénáře ve vaší aplikaci můžou těžit z použití suballokátoru ukládání do mezipaměti, najdete v tématu Plánovač úloh.
asend
Asynchronní operace odeslání, která naplánuje úlohu, která rozšíří data do cílového bloku.
template <class T>
bool asend(
_Inout_ ITarget<T>* _Trg,
const T& _Data);
template <class T>
bool asend(
ITarget<T>& _Trg,
const T& _Data);
Parametry
T
Typ dat, která se mají odeslat.
_Trg
Ukazatel nebo odkaz na cíl, na který se data odesílají.
_Data
Odkaz na data, která se mají odeslat.
Návratová hodnota
true pokud byla zpráva přijata před vrácenou metodou, false jinak.
Poznámky
Další informace naleznete v tématu Funkce předávání zpráv.
cancel_current_task
Zruší aktuálně spuštěnou úlohu. Tuto funkci lze volat z těla úkolu, aby se přerušila spuštění úkolu a způsobila, že přejde do canceled stavu.
Není to podporovaný scénář volání této funkce, pokud nejste v těle .task Výsledkem bude nedefinované chování, jako je chybové ukončení nebo nereagování ve vaší aplikaci.
inline __declspec(noreturn) void __cdecl cancel_current_task();
jasný
Vymaže souběžnou frontu a zničí všechny aktuálně vyčíslené prvky. Tato metoda není bezpečná pro souběžnost.
template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();
Parametry
T
_Sekyra
create_async
Vytvoří prostředí Windows Runtime asynchronní konstruktor založený na zadaném uživateli lambda nebo objektu funkce. Návratový create_async typ je jedním z IAsyncAction^hodnot , IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^nebo IAsyncOperationWithProgress<TResult, TProgress>^ na základě podpisu lambda předaného metodě.
template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
-> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));
Parametry
_Funkce
Typ:
_Func
Lambda nebo objekt funkce, ze kterého chcete vytvořit prostředí Windows Runtime asynchronní konstruktor.
Návratová hodnota
Asynchronní konstruktor reprezentovaný IAsyncAction^, IAsyncActionWithProgress TProgress<>^, IAsyncOperation<TResult>^ nebo IAsyncOperationWithProgress<TResult, TProgress>^. Vrácené rozhraní závisí na podpisu lambda předané do funkce.
Poznámky
Návratový typ lambda určuje, zda je konstruktor akcí nebo operací.
Lambda, které vracejí void, způsobují vytváření akcí. Lambda, které vrací výsledek typu TResult , způsobují vytvoření operací TResult.
Lambda může také vrátit, task<TResult> který zapouzdřuje aysnchronous práci uvnitř sebe nebo je pokračováním řetězce úkolů, které představují asynchronní práci. V tomto případě je lambda spuštěna vložena, protože úlohy jsou úlohy, které se spouští asynchronně, a návratový typ lambda je nepřepsaný, aby vytvořil asynchronní konstruktor vrácený create_async. To znamená, že lambda, která vrací identifikátor void> úkolu<, způsobí vytvoření akcí a lambda, která vrátí úkol<TResult způsobí vytvoření operací TResult>.
Lambda může mít buď nula, jeden nebo dva argumenty. Platné argumenty jsou progress_reporter<TProgress> a cancellation_tokenv tom pořadí, pokud se použijí oba. Lambda bez argumentů způsobí vytvoření asynchronního konstruktoru bez schopnosti generování sestav průběhu. Lambda, která přebírá progress_reporter<TProgress> vrátí create_async asynchronní konstruktor, který hlásí průběh typu TProgress pokaždé, report když je volána metoda progress_reporter objektu. Lambda, která přebírá cancellation_token může tento token použít ke kontrole zrušení, nebo ho předat úkolům, které vytvoří, aby zrušení asynchronní konstrukce způsobí zrušení těchto úloh.
Pokud tělo lambda nebo objekt funkce vrátí výsledek (a ne úkol<TResult>), lamdba se spustí asynchronně v rámci procesu MTA v kontextu úlohy, která modul runtime pro něj implicitně vytvoří. Metoda IAsyncInfo::Cancel způsobí zrušení implicitní úlohy.
Pokud tělo lambda vrátí úlohu, lamba se spustí v řádku a deklarací lambda vezme argument typu cancellation_token , můžete aktivovat zrušení všech úloh, které v lambda vytvoříte, předáním tohoto tokenu při jejich vytváření. Metodu register_callback tokenu můžete také použít k vyvolání zpětného volání modulu Runtime při volání IAsyncInfo::Cancel asynchronní operace nebo akce vytvořené..
Tato funkce je dostupná jenom pro prostředí Windows Runtime aplikace.
CreateResourceManager
Vrátí rozhraní, které představuje jednu instanci Resource Manageru modulu Concurrency Runtime. Správce prostředků zodpovídá za přiřazování prostředků plánovačům, kteří spolu chtějí spolupracovat.
IResourceManager* __cdecl CreateResourceManager();
Návratová hodnota
Rozhraní IResourceManager .
Poznámky
Několik následných volání této metody vrátí stejnou instanci Resource Manageru. Každé volání metody zvýší počet odkazů na Resource Manager a musí se shodovat s voláním metody IResourceManager::Release při komunikaci plánovače s Resource Managerem.
unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.
create_task
Vytvoří objekt úkolu PPL. create_task lze použít kdekoli, kde byste použili konstruktor úloh. Poskytuje se hlavně pro usnadnění práce, protože umožňuje použití klíčového auto slova při vytváření úloh.
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);
Parametry
T
Typ parametru, ze kterého má být úkol vytvořen.
_ReturnType
Typ:
_Param
Parametr, ze kterého má být úkol vytvořen. Může se jednat o objekt lambda nebo funkci, task_completion_event objekt, jiný task objekt nebo rozhraní Windows::Foundation::IAsyncInfo, pokud používáte úlohy v aplikaci pro UPW.
_TaskOptions
Možnosti úkolu.
_Úkol
Úkol, který chcete vytvořit.
Návratová hodnota
Nový úkol typu T, který je odvozen z _Param.
Poznámky
První přetížení se chová jako konstruktor úkolu, který přebírá jeden parametr.
Druhé přetížení přidruží token zrušení poskytnutý k nově vytvořené úloze. Pokud použijete toto přetížení, nesmíte předat jiný task objekt jako první parametr.
Typ vrácené úlohy je odvozen z prvního parametru do funkce. Pokud _Param je , task_completion_event<T>nebo task<T>functor, který vrací buď typ T , nebo task<T>, typ vytvořeného úkolu je task<T>.
Pokud je v aplikaci _Param pro UPW typ Windows::Foundation::IAsyncOperation<T>^ nebo Windows::Foundation::IAsyncOperationWithProgress<T,P>^ nebo functor, který vrátí některý z těchto typů, bude vytvořený úkol typu task<T>. Pokud _Param je typu Windows::Foundation::IAsyncAction^ nebo Windows::Foundation::IAsyncActionWithProgress<P>^, nebo functor, který vrátí některý z těchto typů, bude mít vytvořený úkol typ task<void>.
DisableTracing
Zakáže trasování v concurrency Runtime. Tato funkce je zastaralá, protože trasování trasování Trasování událostí pro Windows je ve výchozím nastavení zrušeno.
__declspec(deprecated("Concurrency::DisableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl DisableTracing();
Návratová hodnota
Pokud bylo trasování správně zakázané, S_OK vrátí se. Pokud trasování nebylo zahájeno dříve, E_NOT_STARTED je vráceno.
EnableTracing
Povolí trasování v concurrency Runtime. Tato funkce je zastaralá, protože trasování trasování událostí pro Windows je teď ve výchozím nastavení zapnuté.
__declspec(deprecated("Concurrency::EnableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl EnableTracing();
Návratová hodnota
Pokud bylo trasování správně zahájeno, S_OK vrátí se. V opačném případě E_NOT_STARTED se vrátí.
Bezplatný
Uvolní blok paměti, který byla dříve přidělena metodou Alloc suballocatoru mezipaměti Concurrency Runtime.
void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);
Parametry
_PAllocation
Ukazatel na paměť, který byla dříve přidělena metodou Alloc , která má být uvolněna. Pokud je parametr _PAllocation nastaven na hodnotu NULL, tato metoda ji ignoruje a vrátí okamžitě.
Poznámky
Další informace o tom, které scénáře ve vaší aplikaci můžou těžit z použití suballokátoru ukládání do mezipaměti, najdete v tématu Plánovač úloh.
get_ambient_scheduler
inline std::shared_ptr<::Concurrency::scheduler_interface> get_ambient_scheduler();
Návratová hodnota
GetExecutionContextId
Vrátí jedinečný identifikátor, který lze přiřadit kontextu spuštění, který implementuje IExecutionContext rozhraní.
unsigned int __cdecl GetExecutionContextId();
Návratová hodnota
Jedinečný identifikátor kontextu spuštění.
Poznámky
Tuto metodu použijte k získání identifikátoru kontextu spuštění předtím, než předáte IExecutionContext rozhraní jako parametr některé z metod nabízených Resource Managerem.
GetOSVersion
Vrátí verzi operačního systému.
IResourceManager::OSVersion __cdecl GetOSVersion();
Návratová hodnota
Výčtová hodnota představující operační systém.
Poznámky
unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.
GetProcessorCount
Vrátí počet hardwarových vláken v podkladovém systému.
unsigned int __cdecl GetProcessorCount();
Návratová hodnota
Počet hardwarových vláken.
Poznámky
unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.
GetProcessorNodeCount
Vrátí počet uzlů NUMA nebo balíčků procesoru v podkladovém systému.
unsigned int __cdecl GetProcessorNodeCount();
Návratová hodnota
Počet uzlů NUMA nebo balíčků procesoru
Poznámky
Pokud systém obsahuje více uzlů NUMA než balíčky procesoru, vrátí se počet uzlů NUMA, jinak se vrátí počet balíčků procesoru.
unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.
GetSchedulerId
Vrátí jedinečný identifikátor, který lze přiřadit plánovači, který implementuje IScheduler rozhraní.
unsigned int __cdecl GetSchedulerId();
Návratová hodnota
Jedinečný identifikátor plánovače.
Poznámky
Tuto metodu použijte k získání identifikátoru plánovače před předáním IScheduler rozhraní jako parametru některé z metod nabízených Resource Managerem.
internal_assign_iterators
template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
_I first,
_I last);
Parametry
T
_Sekyra
_Já
první
poslední
interruption_point
Vytvoří bod přerušení pro zrušení. Pokud probíhá zrušení v kontextu, kde je tato funkce volána, vyvolá se vnitřní výjimka, která přeruší provádění aktuálně spuštěné paralelní práce. Pokud zrušení neprobíhá, funkce nic nedělá.
inline void interruption_point();
Poznámky
Neměli byste zachytávat vnitřní výjimku zrušení vyvolanou interruption_point() funkcí. Výjimka bude zachycena a zpracována modulem runtime a zachycení může způsobit, že se váš program bude chovat neobvykle.
is_current_task_group_canceling
Vrátí informaci o tom, jestli je skupina úloh, která se právě spouští v aktuálním kontextu, uprostřed aktivního zrušení (nebo brzy). Všimněte si, že pokud v aktuálním kontextu aktuálně nespouštějí žádnou skupinu úloh, false bude vrácena.
bool __cdecl is_current_task_group_canceling();
Návratová hodnota
true pokud skupina úloh, která se právě spouští, se ruší, false jinak.
Poznámky
Další informace najdete v tématu Zrušení.
make_choice
choice Vytvoří blok zasílání zpráv z volitelných Scheduler nebo ScheduleGroup dvou nebo více vstupních zdrojů.
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);
Parametry
T1
Typ bloku zprávy prvního zdroje
T2
Typ bloku zprávy druhého zdroje
_PScheduler
Objekt Scheduler , ve kterém je naplánována úloha šíření bloku choice zasílání zpráv.
_Item1
První zdroj.
_Item2
Druhý zdroj.
_Položky
Další zdroje.
_PScheduleGroup
Objekt ScheduleGroup , ve kterém je naplánována úloha šíření bloku choice zasílání zpráv. Použitý Scheduler objekt je odvozen ze skupiny plánů.
Návratová hodnota
Blok choice zprávy se dvěma nebo více vstupními zdroji
make_greedy_join
greedy multitype_join Vytvoří blok zasílání zpráv z volitelných Scheduler nebo ScheduleGroup dvou nebo více vstupních zdrojů.
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);
Parametry
T1
Typ bloku zprávy prvního zdroje
T2
Typ bloku zprávy druhého zdroje
_PScheduler
Objekt Scheduler , ve kterém je naplánována úloha šíření bloku multitype_join zasílání zpráv.
_Item1
První zdroj.
_Item2
Druhý zdroj.
_Položky
Další zdroje.
_PScheduleGroup
Objekt ScheduleGroup , ve kterém je naplánována úloha šíření bloku multitype_join zasílání zpráv. Použitý Scheduler objekt je odvozen ze skupiny plánů.
Návratová hodnota
Blok greedy multitype_join zprávy se dvěma nebo více vstupními zdroji
make_join
non_greedy multitype_join Vytvoří blok zasílání zpráv z volitelných Scheduler nebo ScheduleGroup dvou nebo více vstupních zdrojů.
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);
Parametry
T1
Typ bloku zprávy prvního zdroje
T2
Typ bloku zprávy druhého zdroje
_PScheduler
Objekt Scheduler , ve kterém je naplánována úloha šíření bloku multitype_join zasílání zpráv.
_Item1
První zdroj.
_Item2
Druhý zdroj.
_Položky
Další zdroje.
_PScheduleGroup
Objekt ScheduleGroup , ve kterém je naplánována úloha šíření bloku multitype_join zasílání zpráv. Použitý Scheduler objekt je odvozen ze skupiny plánů.
Návratová hodnota
Blok non_greedy multitype_join zprávy se dvěma nebo více vstupními zdroji
make_task
Metoda továrny pro vytvoření objektu task_handle .
template <class _Function>
task_handle<_Function> make_task(const _Function& _Func);
Parametry
_Funkce
Typ objektu funkce, který bude vyvolán ke spuštění práce reprezentované objektem task_handle .
_Func
Funkce, která bude vyvolána ke spuštění práce reprezentované objektem task_handle . Může to být lambda functor, ukazatel na funkci nebo jakýkoli objekt, který podporuje verzi operátoru volání funkce s podpisem void operator()().
Návratová hodnota
Objekt task_handle .
Poznámky
Tato funkce je užitečná, když potřebujete vytvořit task_handle objekt s výrazem lambda, protože umožňuje vytvořit objekt bez znalosti skutečného typu lambda functor.
parallel_buffered_sort
Uspořádá prvky v zadaném rozsahu do nesestupné pořadí nebo podle kritéria řazení určeného binárním predikátem paralelně. Tato funkce je sémanticky podobná std::sort tomu, že se jedná o porovnávané, nestabilní, místní řazení s tím rozdílem, že potřebuje O(n) další prostor a vyžaduje výchozí inicializaci pro seřazené prvky.
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);
Parametry
_Random_iterator
Typ iterátoru vstupního rozsahu.
_Alokátor
Typ alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.
_Funkce
Typ binárního komparátoru.
_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.
_Konec
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má seřadit.
_Alloc
Instance alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.
_Func
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny. Tato porovnávací funkce musí u párů prvků ze sekvence uložit striktní slabé pořadí.
_Chunk_size
Velikost mimimum bloku dat, která bude rozdělena do dvou pro paralelní provádění.
Poznámky
Všechna přetížení vyžadují n * sizeof(T) další prostor, kde n je počet prvků, které mají být seřazeny, a T je typ prvku. Ve většině případů parallel_buffered_sort zobrazí zlepšení výkonu oproti parallel_sort a pokud máte k dispozici paměť, měli byste ho použít přes parallel_sort.
Pokud nezadáte binární komparátor std::less , použije se jako výchozí, který vyžaduje typ prvku k poskytnutí operátoru operator<().
Pokud nezadáte typ nebo instanci alokátoru, k přidělení vyrovnávací paměti se použije alokátor std::allocator<T> standardní knihovny jazyka C++.
Algoritmus rozdělí vstupní rozsah na dva bloky dat a postupně rozdělí každý blok dat do dvou dílčích bloků dat pro paralelní spuštění. Volitelný argument _Chunk_size lze použít k označení algoritmu, že by měl zpracovávat bloky velikosti <_Chunk_size serialně.
parallel_for
parallel_for iteruje v rozsahu indexů a provádí uživatelsky zadanou funkci paralelně při každé iteraci.
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);
Parametry
_Index_type
Typ indexu, který se používá pro iteraci.
_Funkce
Typ funkce, která se spustí při každé iteraci.
_Partitioner
Typ rozdělovače, který se používá k rozdělení zadaného rozsahu.
první
První index, který se má zahrnout do iterace.
poslední
Index je za posledním indexem, který se má zahrnout do iterace.
_Krok
Hodnota, o kterou se má krokovat při iteraci z first do last. Tento krok musí být pozitivní. invalid_argument je vyvolán, pokud je krok menší než 1.
_Func
Funkce, která se má spustit při každé iteraci. Může se jednat o výraz lambda, ukazatel funkce nebo jakýkoli objekt, který podporuje verzi operátoru volání funkce s podpisem void operator()(_Index_type).
_Část
Odkaz na objekt partitioneru. Argumentem může být jeden z const auto_partitioner&, const static_partitioner&, const simple_partitioner nebo affinity_partitioner&& Pokud se použije objekt affinity_partitioner, musí být odkaz odkazem nekonstanční l-hodnota, aby algoritmus mohl uložit stav pro budoucí smyčky k opětovnému použití.
Poznámky
Další informace naleznete v tématu Paralelní algoritmy.
parallel_for_each
parallel_for_each použije zadanou funkci na každý prvek v rozsahu paralelně. Je sémanticky ekvivalentní for_each funkci v std oboru názvů s tím rozdílem, že iterace nad prvky se provádí paralelně a pořadí iterace není zadáno. Argument _Func musí podporovat operátor volání funkce formuláře operator()(T) , kde parametr T je typ položky kontejneru iterated.
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);
Parametry
_Iterátor
Typ iterátoru, který se používá k iteraci kontejneru.
_Funkce
Typ funkce, která bude použita pro každý prvek v rozsahu.
_Partitioner
první
Iterátor adresuje pozici prvního prvku, který se má zahrnout do paralelní iterace.
poslední
Iterátor adresuje pozici po posledním prvku, který se má zahrnout do paralelní iterace.
_Func
Uživatelem definovaný objekt funkce, který je použit pro každý prvek v rozsahu.
_Část
Odkaz na objekt partitioneru. Argumentem může být jeden z const auto_partitioner&, const static_partitioner&, const simple_partitioner nebo affinity_partitioner&& Pokud se použije objekt affinity_partitioner, musí být odkaz odkazem nekonstanční l-hodnota, aby algoritmus mohl uložit stav pro budoucí smyčky k opětovnému použití.
Poznámky
auto_partitioner bude použita pro přetížení bez explicitního dělitele.
Pro iterátory, které nepodporují náhodný přístup, se podporuje pouze auto_partitioner .
Další informace naleznete v tématu Paralelní algoritmy.
parallel_invoke
Spustí objekty funkcí zadané jako parametry paralelně a bloky, dokud se nedokončí jejich provádění. Každý objekt funkce může být výraz lambda, ukazatel na funkci nebo jakýkoli objekt, který podporuje operátor volání funkce s podpisem 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);
Parametry
_Function1
Typ prvního objektu funkce, který se má spustit paralelně.
_Function2
Typ druhého objektu funkce, který se má spustit paralelně.
_Function3
Typ třetího objektu funkce, který se má spustit paralelně.
_Function4
Typ čtvrtého objektu funkce, který se má spustit paralelně.
_Function5
Typ pátého objektu funkce, který se má spustit paralelně.
_Function6
Typ šestého objektu funkce, který se má spustit paralelně.
_Function7
Typ sedmého objektu funkce, který se má spustit paralelně.
_Function8
Typ osmého objektu funkce, který se má spustit paralelně.
_Function9
Typ devátého objektu funkce, který se má spustit paralelně.
_Function10
Typ desátého objektu funkce, který se má spustit paralelně.
_Func1
První objekt funkce, který se má spustit paralelně.
_Func2
Druhý objekt funkce, který se má spustit paralelně.
_Func3
Třetí objekt funkce, který se má spustit paralelně.
_Func4
Čtvrtý objekt funkce, který se má spustit paralelně.
_Func5
Pátý objekt funkce, který se má spustit paralelně.
_Func6
Šestý objekt funkce, který se má spustit paralelně.
_Func7
Sedmý objekt funkce, který se má spustit paralelně.
_Func8
Osmý objekt funkce, který se má spustit paralelně.
_Func9
Devátý objekt funkce, který se má spustit paralelně.
_Func10
Desátý objekt funkce, který se má spustit paralelně.
Poznámky
Všimněte si, že jeden nebo více objektů funkcí zadaných jako parametry se může spustit v kontextu volání.
Pokud jeden nebo více objektů funkce předaných jako parametry této funkce vyvolá výjimku, modul runtime vybere jednu takovou výjimku z výběru a rozšíří ho mimo volání parallel_invoke.
Další informace naleznete v tématu Paralelní algoritmy.
parallel_radixsort
Uspořádá prvky v zadaném rozsahu do nesestupné pořadí pomocí algoritmu řazení paprsků. Jedná se o stabilní funkci řazení, která vyžaduje projekční funkci, která může projektovat prvky seřazené do nepodepsaných celočíselného klíče. Pro seřazené prvky se vyžaduje výchozí inicializace.
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);
Parametry
_Random_iterator
Typ iterátoru vstupního rozsahu.
_Alokátor
Typ alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.
_Funkce
Typ projekční funkce.
_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.
_Konec
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má seřadit.
_Alloc
Instance alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.
_Proj_func
Objekt funkce projekce definovaný uživatelem, který převede prvek na celočíselnou hodnotu.
_Chunk_size
Velikost mimimum bloku dat, která bude rozdělena do dvou pro paralelní provádění.
Poznámky
Všechna přetížení vyžadují n * sizeof(T) další prostor, kde n je počet prvků, které mají být seřazeny, a T je typ prvku. Unární projekční functor s podpisem I _Proj_func(T) je vyžadován k vrácení klíče při zadání prvku, kde T je typ prvku a I je nepodepsaný celočíselnou typ.
Pokud nezadáte projekční funkci, použije se výchozí projekční funkce, která jednoduše vrátí prvek pro celočíselné typy. Funkce se nepovede zkompilovat, pokud prvek není celočíselným typem bez projekce funkce.
Pokud nezadáte typ nebo instanci alokátoru, k přidělení vyrovnávací paměti se použije alokátor std::allocator<T> standardní knihovny jazyka C++.
Algoritmus rozdělí vstupní rozsah na dva bloky dat a postupně rozdělí každý blok dat do dvou dílčích bloků dat pro paralelní spuštění. Volitelný argument _Chunk_size lze použít k označení algoritmu, že by měl zpracovávat bloky velikosti <_Chunk_size serialně.
parallel_reduce
Vypočítá součet všech prvků v zadaném rozsahu výpočtem po sobě jdoucích částečných součtů nebo vypočítá výsledek po sobě jdoucích částečných výsledků podobně získaných pomocí zadané binární operace jiné než součet paralelně. parallel_reduce je sémanticky podobný std::accumulate, s výjimkou toho, že vyžaduje, aby binární operace byla asociativní, a vyžaduje hodnotu identity místo počáteční hodnoty.
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);
Parametry
_Forward_iterator
Typ iterátoru vstupního rozsahu.
_Sym_reduce_fun
Typ symetrické redukční funkce. Musí to být typ funkce s podpisem _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), kde _Reduce_type je stejný jako typ identity a typ výsledku redukce. Pro třetí přetížení by to mělo být konzistentní s výstupním _Range_reduce_funtypem .
_Reduce_type
Typ, na který se vstup sníží, což se může lišit od typu vstupního prvku. Vrácená hodnota a hodnota identity bude mít tento typ.
_Range_reduce_fun
Typ funkce redukce rozsahu. Musí to být typ funkce s podpisem _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type je stejný jako typ identity a typ výsledku redukce.
_Začít
Vstupní iterátor adresovaný prvním prvkem v rozsahu, který se má snížit.
_Konec
Vstupní iterátor adresovaný prvku, který je o jednu pozici nad posledním prvkem v rozsahu, který se má snížit.
_Identita
Hodnota _Identity identity je stejného typu jako typ výsledku redukce a také value_type iterátoru pro první a druhé přetížení. U třetího přetížení musí mít hodnota identity stejný typ jako typ výsledku redukce, ale může se lišit od value_type iterátoru. Musí mít odpovídající hodnotu, aby operátor _Range_funredukce rozsahu , při použití na rozsah jednoho prvku typu value_type a hodnoty identity se chová jako typ přetypování hodnoty z typu value_type na typ typu.
_Sym_fun
Symetrická funkce, která se použije v sekundě redukce. Další informace najdete v poznámkách.
_Range_fun
Funkce, která se použije v první fázi redukce. Další informace najdete v poznámkách.
Návratová hodnota
Výsledek redukce.
Poznámky
Aby se provedlo paralelní snížení, funkce rozdělí rozsah na bloky dat na základě počtu pracovních procesů dostupných pro podkladový plánovač. Redukce probíhá ve dvou fázích, první fáze provádí redukci v rámci každého bloku a druhá fáze provádí redukci mezi částečnými výsledky z každého bloku.
První přetížení vyžaduje, aby iterátor value_type, Tmusí být stejný jako typ hodnoty identity a také typ výsledku redukce. Typ elementu T musí poskytnout operátor T T::operator + (T) pro redukci prvků v jednotlivých blocích. Stejný operátor se používá i ve druhé fázi.
Druhé přetížení také vyžaduje, aby iterátor value_type byl stejný jako typ hodnoty identity i typ výsledku redukce. Zadaný binární operátor _Sym_fun se používá v obou fázích redukce s hodnotou identity jako počáteční hodnotou první fáze.
U třetího přetížení musí být typ hodnoty identity stejný jako typ výsledku redukce, ale iterátor value_type se může lišit od obou. Funkce _Range_fun redukce rozsahu se používá v první fázi s hodnotou identity jako počáteční hodnotou a binární funkce _Sym_reduce_fun se použije na dílčí výsledky ve druhé fázi.
parallel_sort
Uspořádá prvky v zadaném rozsahu do nesestupné pořadí nebo podle kritéria řazení určeného binárním predikátem paralelně. Tato funkce se sémanticky podobá std::sort tomu, že se jedná o porovnání založené na nestabilním a místní řazení.
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);
Parametry
_Random_iterator
Typ iterátoru vstupního rozsahu.
_Funkce
Typ trychtoru binárního porovnání.
_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.
_Konec
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má seřadit.
_Func
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny. Tato porovnávací funkce musí u párů prvků ze sekvence uložit striktní slabé pořadí.
_Chunk_size
Minimální velikost bloku dat, která bude rozdělena do dvou pro paralelní provádění.
Poznámky
První přetížení používá binární komparátor std::less.
Druhá přetížená používá zadaný binární srovnávací program, který by měl mít podpis bool _Func(T, T) , kde T je typ prvků ve vstupním rozsahu.
Algoritmus rozdělí vstupní rozsah na dva bloky dat a postupně rozdělí každý blok dat do dvou dílčích bloků dat pro paralelní spuštění. Volitelný argument _Chunk_size lze použít k označení algoritmu, že by měl zpracovávat bloky velikosti <_Chunk_size serialně.
parallel_transform
Použije zadaný objekt funkce na každý prvek ve zdrojovém rozsahu nebo na dvojici prvků ze dvou zdrojových oblastí a paralelně zkopíruje návratové hodnoty objektu funkce do cílového rozsahu. Tato funkce je sémanticky ekvivalentní 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);
Parametry
_Input_iterator1
Typ prvního nebo jediného vstupního iterátoru.
_Output_iterator
Typ výstupního iterátoru.
_Unary_operator
Typ unárního functoru, který se má provést u každého prvku ve vstupním rozsahu.
_Input_iterator2
Typ druhého vstupního iterátoru.
_Binary_operator
Typ binárního functoru se spustil párově u prvků ze dvou zdrojových oblastí.
_Partitioner
první 1
Vstupní iterátor adresuje pozici prvního prvku v prvním nebo jediném zdrojovém rozsahu, na který se má pracovat.
poslední 1
Vstupní iterátor adresuje pozici za posledním prvkem v prvním nebo jediném zdrojovém rozsahu, na které se má pracovat.
_Výsledek
Výstupní iterátor adresuje pozici prvního prvku v cílovém rozsahu.
_Unary_op
Objekt unární funkce definovaný uživatelem, který je použit pro každý prvek ve zdrojovém rozsahu.
_Část
Odkaz na objekt partitioneru. Argumentem může být jeden z const auto_partitioner&, const static_partitioner&, const simple_partitioner nebo affinity_partitioner&& Pokud se použije objekt affinity_partitioner, musí být odkaz odkazem nekonstanční l-hodnota, aby algoritmus mohl uložit stav pro budoucí smyčky k opětovnému použití.
první2
Vstupní iterátor adresuje pozici prvního prvku ve druhém zdrojovém rozsahu, na který se má pracovat.
_Binary_op
Objekt binární funkce definovaný uživatelem, který se použije ve spárovacím pořadí, do dvou zdrojových oblastí.
Návratová hodnota
Výstupní iterátor adresovaný pozici za posledním prvkem v cílovém rozsahu, který přijímá výstupní prvky transformované objektem funkce.
Poznámky
auto_partitioner budou použity pro přetížení bez explicitního argumentu partitioneru.
Pro iterátory, které nepodporují náhodný přístup, se podporuje pouze auto_partitioner .
Přetížení, která převezmou argument _Unary_op transformují vstupní oblast do výstupní oblasti použitím unárního functoru na každý prvek ve vstupní oblasti. _Unary_op musí podporovat operátor volání funkce s podpisem operator()(T) , kde T je typ hodnoty rozsahu iterated.
Přetížení, která přebírají argument _Binary_op transformují dva vstupní oblasti do výstupní oblasti použitím binárního functoru na jeden prvek z první vstupní oblasti a jeden prvek z druhé vstupní oblasti. _Binary_op musí podporovat operátor volání funkce s podpisem operator()(T, U) , kde Tjsou U typy hodnot dvou vstupních iterátorů.
Další informace naleznete v tématu Paralelní algoritmy.
obdržet
Obecná implementace příjmu, která umožňuje kontextu čekat na data z přesně jednoho zdroje a filtrovat hodnoty, které jsou přijaty.
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);
Parametry
T
Typ datové části.
_Src
Ukazatel nebo odkaz na zdroj, ze kterého se očekává data.
_Přerušení zápasu
Maximální doba, po kterou by metoda měla pro data v milisekundách.
_Filter_proc
Funkce filtru, která určuje, zda mají být zprávy přijaty.
Návratová hodnota
Hodnota ze zdroje typu datové části.
Poznámky
Pokud má parametr _Timeout jinou hodnotu než konstanta COOPERATIVE_TIMEOUT_INFINITE, výjimka operation_timed_out je vyvolán, pokud zadané množství času vyprší před přijetí zprávy. Pokud chcete vypršení časového limitu nulové délky, měli byste místo volání s časovým limitem 0 (nula) použít funkci try_receive, protože je efektivnější a nevyvolá receive výjimky u časových limitů.
Další informace naleznete v tématu Funkce předávání zpráv.
run_with_cancellation_token
Provede objekt funkce okamžitě a synchronně v kontextu daného tokenu zrušení.
template<typename _Function>
void run_with_cancellation_token(
const _Function& _Func,
cancellation_token _Ct);
Parametry
_Funkce
Typ objektu funkce, který bude vyvolán.
_Func
Objekt funkce, který se spustí. Tento objekt musí podporovat operátor volání funkce s podpisem void(void).
_Ct
Token zrušení, který bude řídit implicitní zrušení objektu funkce. Použijte cancellation_token::none() , pokud chcete, aby se funkce spustila bez možnosti implicitního zrušení z nadřazené skupiny úloh.
Poznámky
Všechny body přerušení v objektu funkce se aktivují při cancellation_token zrušení. Explicitní token _Ct izoluje toto _Func od nadřazeného zrušení, pokud má nadřazený objekt jiný token nebo žádný token.
poslat
Synchronní operace odesílání, která čeká, dokud cíl zprávu přijme nebo odmítne.
template <class T>
bool send(_Inout_ ITarget<T>* _Trg, const T& _Data);
template <class T>
bool send(ITarget<T>& _Trg, const T& _Data);
Parametry
T
Typ datové části.
_Trg
Ukazatel nebo odkaz na cíl, na který se data odesílají.
_Data
Odkaz na data, která se mají odeslat.
Návratová hodnota
true pokud byla zpráva přijata, false jinak.
Poznámky
Další informace naleznete v tématu Funkce předávání zpráv.
set_ambient_scheduler
inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);
Parametry
_Plánovač
Okolí plánovače, který chcete nastavit.
set_task_execution_resources
Omezuje spouštěcí prostředky používané interními pracovními vlákny Concurrency Runtime na zadanou sadu spřažení.
Tato metoda je platná pouze před vytvořením Resource Manageru nebo mezi dvěma životnostmi Resource Manageru. Je možné ji vyvolat vícekrát, pokud Resource Manager v době vyvolání neexistuje. Po nastavení limitu spřažení zůstane v platnosti až do dalšího platného volání set_task_execution_resources metody.
Zadanou maskou spřažení nemusí být podmnožinou masky spřažení procesu. V případě potřeby se spřažení procesu aktualizuje.
void __cdecl set_task_execution_resources(
DWORD_PTR _ProcessAffinityMask);
void __cdecl set_task_execution_resources(
unsigned short count,
PGROUP_AFFINITY _PGroupAffinity);
Parametry
_ProcessAffinityMask
Maska spřažení, na kterou mají být omezena pracovní vlákna Concurrency Runtime. Tuto metodu použijte v systému s více než 64 hardwarovými vlákny pouze v případě, že chcete omezit modul Concurrency Runtime na podmnožinu aktuální skupiny procesorů. Obecně byste měli použít verzi metody, která přijímá pole spřažení skupin jako parametr, chcete-li omezit spřažení na počítačích s více než 64 hardwarovými vlákny.
count
Počet GROUP_AFFINITY položek v matici určené parametrem _PGroupAffinity.
_PGroupAffinity
Pole GROUP_AFFINITY položek.
Poznámky
Metoda vyvolá výjimku invalid_operation , pokud je v době vyvolání k dispozici Resource Manager, a invalid_argument výjimka, pokud zadaný spřažení způsobí prázdnou sadu prostředků.
Verze metody, která jako parametr přebírá pole spřažení skupin, by měla být použita pouze v operačních systémech s windows 7 nebo vyšší. V opačném případě se vyvolá výjimka invalid_operation.
Změna spřažení procesu po vyvolání této metody prostřednictvím kódu programu nezpůsobí opětovné vyhodnocení spřažení Resource Manageru. Proto by před voláním této metody měly být provedeny všechny změny spřažení procesu.
swap
Vymění prvky dvou concurrent_vector objektů.
template<typename T, class _Ax>
inline void swap(
concurrent_vector<T, _Ax>& _A,
concurrent_vector<T, _Ax>& _B);
Parametry
T
Datový typ prvků uložených v souběžných vektorech.
_Sekyra
Typ alokátoru souběžných vektorů.
_A
Souběžný vektor, jehož prvky se mají vyměňovat s prvky souběžného vektoru _B.
_B
Souběžný vektor poskytující prvky, které mají být prohozeny, nebo vektor, jehož prvky mají být vyměňovány s prvky souběžného vektoru _A.
Poznámky
Funkce šablony je algoritmus specializovaný na třídu concurrent_vector kontejneru pro spuštění členské funkce _A. concurrent_vector::swap( _B). Jedná se o instance částečného řazení šablon funkcí kompilátorem. Pokud jsou funkce šablony přetíženy takovým způsobem, že shoda šablony s voláním funkce není jedinečná, kompilátor vybere nejspecializovaných verzí funkce šablony. Obecná verze funkce šablony , , template <class T> void swap(T&, T&)v algoritmu třídy funguje podle přiřazení a je pomalá operace. Specializovaná verze v každém kontejneru je mnohem rychlejší, protože dokáže pracovat s interní reprezentací třídy kontejneru.
Tato metoda není bezpečná pro souběžnost. Při volání této metody je nutné zajistit, aby žádné další vlákna prováděla operace s některým ze souběžných vektorů.
task_from_exception
template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(
_ExType _Exception,
const task_options& _TaskOptions = task_options());
Parametry
_TaskType
_ExType
_Výjimka
_TaskOptions
Návratová hodnota
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());
Parametry
T
_Param
_TaskOptions
Návratová hodnota
Trace_agents_register_name
Přidruží daný název k bloku zprávy nebo agentu v trasování Trasování událostí pro Windows.
template <class T>
void Trace_agents_register_name(
_Inout_ T* _PObject,
_In_z_ const wchar_t* _Name);
Parametry
T
Typ objektu. Obvykle se jedná o blok zpráv nebo agenta.
_PObject
Ukazatel na blok zprávy nebo agent, který je v trasování pojmenován.
_Jméno
Název daného objektu.
try_receive
Obecná implementace try-receive, která umožňuje kontextu hledat data z přesně jednoho zdroje a filtrovat hodnoty, které jsou přijaty. Pokud data nejsou připravena, metoda vrátí 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);
Parametry
T
Typ datové části
_Src
Ukazatel nebo odkaz na zdroj, ze kterého se očekává data.
_hodnota
Odkaz na umístění, kde bude výsledek umístěn.
_Filter_proc
Funkce filtru, která určuje, zda mají být zprávy přijaty.
Návratová hodnota
Hodnota bool označující, zda byla datová část umístěna do _value.
Poznámky
Další informace naleznete v tématu Funkce předávání zpráv.
wait
Pozastaví aktuální kontext po zadanou dobu.
void __cdecl wait(unsigned int _Milliseconds);
Parametry
_Milisekundy
Počet milisekund, pro který má být aktuální kontext pozastaven. _Milliseconds Pokud je parametr nastaven na hodnotu 0, aktuální kontext by měl před pokračováním přinést spuštění do jiných spustitelných kontextů.
Poznámky
Pokud je tato metoda volána v kontextu plánovače Concurrency Runtime, plánovač najde jiný kontext, který se má spustit v podkladovém prostředku. Vzhledem k tomu, že plánovač je v podstatě spolupracující, nemůže tento kontext pokračovat přesně po zadaném počtu milisekund. Pokud je plánovač zaneprázdněn prováděním dalších úkolů, které nesdělují spolupráci plánovači, může být čekací doba neomezená.
when_all
Vytvoří úlohu, která se úspěšně dokončí, když se úspěšně dokončí všechny úkoly zadané jako argumenty.
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));
Parametry
_Iterátor
Typ vstupního iterátoru.
_Začít
Pozice prvního prvku v rozsahu prvků, které se mají zkombinovat do výsledného úkolu.
_Konec
Pozice prvního prvku nad rozsah prvků, které se mají zkombinovat do výsledného úkolu.
_TaskOptions
Objekt task_options
Návratová hodnota
Úkol, který se úspěšně dokončí, když byly úspěšně dokončeny všechny vstupní úkoly. Pokud jsou vstupní úkoly typu T, výstupem této funkce bude task<std::vector<T>>. Pokud jsou vstupní úkoly typuvoid, výstupní úkol bude také .task<void>
Poznámky
when_all je neblokující funkce, která vygeneruje task výsledek. Na rozdíl od úkolu::wait je bezpečné tuto funkci volat v aplikaci UPW ve vlákně ASTA (Application STA).
Pokud je některý z úkolů zrušen nebo vyvolá výjimku, vrácený úkol se dokončí dříve, v zrušeném stavu a výjimka, pokud dojde k některé z nich, bude vyvolána, pokud voláte úkol::get nebo task::wait na daném úkolu.
Další informace naleznete v tématu Paralelismus úkolu.
when_any
Vytvoří úlohu, která se úspěšně dokončí, když se úspěšně dokončí některý z úkolů zadaných jako argumenty.
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));
Parametry
_Iterátor
Typ vstupního iterátoru.
_Začít
Pozice prvního prvku v rozsahu prvků, které se mají zkombinovat do výsledného úkolu.
_Konec
Pozice prvního prvku nad rozsah prvků, které se mají zkombinovat do výsledného úkolu.
_TaskOptions
_CancellationToken
Token zrušení, který řídí zrušení vrácené úlohy. Pokud nezadáte token zrušení, výsledná úloha obdrží token zrušení úkolu, který způsobí jeho dokončení.
Návratová hodnota
Úkol, který se úspěšně dokončí, když se úspěšně dokončil některý ze vstupních úkolů. Pokud jsou vstupní úkoly typu T, výstupem této funkce bude task<std::pair<T, size_t>>>, kde první prvek dvojice je výsledkem dokončení úkolu a druhý prvek je index dokončeného úkolu. Pokud jsou vstupní úkoly typu void výstupu , task<size_t>kde je výsledkem index dokončení úkolu.
Poznámky
when_any je neblokující funkce, která vygeneruje task výsledek. Na rozdíl od úkolu::wait je bezpečné tuto funkci volat v aplikaci UPW ve vlákně ASTA (Application STA).
Další informace naleznete v tématu Paralelismus úkolu.