egyidejűség névtérfüggvényei

A névtérben a következő függvények érhetők el:

Alloc

Az Egyidejű Futtatókörnyezet Gyorsítótárazási Alsóallokálójától megadott méretű memóriablokkot foglal le.

void* __cdecl Alloc(size_t _NumBytes);

Paraméterek

_NumBytes
A lefoglalni kívánt memória bájtjainak száma.

Visszaadott érték

Mutató az újonnan lefoglalt memóriára.

Megjegyzések

További információért arról, hogy az alkalmazás mely forgatókönyvei számára lehet előnyös a gyorsítótár alallokátor használata, tekintse meg a Feladatütemezőt.

asend

Aszinkron küldési művelet, amely ütemez egy feladatot az adatok célblokkba való propagálására.

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

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

Paraméterek

T
Az elküldendő adatok típusa.

_Trg
Mutató vagy hivatkozás arra a célra, amelyre az adatokat küldi.

_Adat
Hivatkozás az elküldendő adatokra.

Visszaadott érték

, ha az üzenetet a függvény visszatérése előtt fogadták el, ellenkező esetben.

Megjegyzések

További információ: Üzenetátadási függvények.

feladat_megszakítása_aktuális

Megszakítja az aktuálisan végrehajtó feladatot. Ez a függvény meghívható a tevékenység törzséből a tevékenység végrehajtásának megszakításához, és a állapotba való belépéséhez.

Nem támogatott forgatókönyv a függvény meghívása, ha nem egy törzsében van. Ha így tesz, az nem definiált viselkedést eredményez, például összeomlást vagy nem válaszolást az alkalmazásban.

inline __declspec(noreturn) void __cdecl cancel_current_task();

átlátszó

Törli az egyidejű üzenetsort, és megsemmisíti a jelenleg lekért elemeket. Ez a módszer nem egyidejűségbiztos.

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

Paraméterek

_Ax

create_async

Létrehoz egy Windows-futtatókörnyezet aszinkron szerkezetet egy felhasználó által megadott lambda vagy függvényobjektum alapján. A visszatérési típusa a , , , vagy egyike, a metódusba átadott lambda aláírása alapján.

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

Paraméterek

_Funkció
Típus.

_Func
Az a lambda vagy függvényobjektum, amelyből Windows-futtatókörnyezet aszinkron szerkezetet hozhat létre.

Visszaadott érték

Egy aszinkron szerkezet, amelyet az IAsyncAction^, IAsyncActionWithProgressTProgress^, IAsyncOperationTResult^, vagy IAsyncOperationWithProgressTResult, TProgress^ által képviselnek. A visszaadott felület a függvénybe átadott lambda aláírásától függ.

Megjegyzések

A lambda visszatérési típusa határozza meg, hogy a konstrukció akció vagy művelet.

Az ürességet visszahozó lambdák a műveletek létrehozását okozzák. A típusú eredményt visszaadó lambdák a TResult műveleteinek létrehozását okozzák.

A lambda visszaadhat egy olyan elemet is, amely magába foglalja az aszinkron munkát, vagy folytatása egy olyan feladatláncnak, amely az aszinkron munkát képviseli. Ebben az esetben maga a lambda lesz végrehajtva beágyazottan, mivel a feladatok azok, amelyek aszinkron módon hajtanak végre, és a lambda visszatérési típusa nincs leképezve az által visszaadott aszinkron szerkezet létrehozásához. Ez azt jelenti, hogy a feladatokatüres visszaadó lambda műveletek létrehozását fogja eredményezni, és a feladatokatTResult visszaadó lambda a TResult műveleteinek létrehozását fogja okozni.

A lambda értéke lehet nulla, egy vagy két argumentum. Az érvényes argumentumok és , ebben a sorrendben, ha mindkettőt használják. Az argumentumok nélküli lambda aszinkron szerkezetet hoz létre anélkül, hogy képes a folyamatjelentésre. A progress_reporterTProgress használó lambda esetén a egy aszinkron szerkezetet ad vissza, amely a progress_reporter objektum metódusának meghívásakor a TProgress típusú előrehaladást jelenti. Egy olyan lambda, amely egy cancellation_token-t használ, felhasználhatja ezt a tokent a lemondás ellenőrzéséhez, vagy az általa létrehozott feladatoknak adja át, hogy az aszinkron szerkezet törlése a feladatok törlését okozza.

Ha a lambda vagy függvényobjektum törzse egy eredményt ad vissza (és nem egy task), a lambda aszinkron módon lesz végrehajtva a folyamat MTA-jában, egy olyan feladat kontextusában, amelyet a futtatókörnyezet implicit módon hoz létre. A metódus az implicit tevékenység törlését okozza.

Ha a lambda törzse egy feladatot ad vissza, a lambda beágyazott végrehajtást végez, és a lambda típus argumentumának deklarálásával elindíthatja a lambdán belül létrehozott tevékenységek törlését úgy, hogy átadja a jogkivonatot a létrehozásukkor. A jogkivonat metódusával elérheti, hogy a futtatókörnyezet egy visszahívási függvényt hívjon meg, amikor az metódust alkalmazza az előállított aszinkron műveleten vagy cselekményen.

Ez a függvény csak Windows-futtatókörnyezet alkalmazások számára érhető el.

CreateResourceManager

Visszaad egy interfészt, amely az Egyidejűségi Futtatókörnyezet Resource Manager szingelton példányát képviseli. A Resource Manager felelős azért, hogy erőforrásokat rendeljen az egymással együttműködő ütemezőkhöz.

IResourceManager* __cdecl CreateResourceManager();

Visszaadott érték

Egy felület.

Megjegyzések

A metódus több későbbi hívása azonos példányt ad vissza a Resource Managerből. A metódus minden egyes hívása növeli a Resource Manager hivatkozási számát, és a IResourceManager::Release metódust hívást kell alkalmazni, amikor az ütemező befejezte a kommunikációt a Resource Managerrel.

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

feladat_létrehozás

Létrehoz egy PPL-feladat objektumot. bárhol használható, ahol korábban feladatkonstruktort használt volna. Ez elsősorban a kényelem érdekében érhető el, mivel lehetővé teszi a kulcsszó használatát a tevékenységek létrehozásakor.

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

Paraméterek

T
Annak a paraméternek a típusa, amelyből a feladatot létre kell venni.

_ReturnType
Típus.

_Param
Az a paraméter, amelyből a feladatot létre kell hozni. Ez lehet lambda vagy függvényobjektum, task_completion_event objektum, egy másik task objektum vagy egy Windows::Foundation::IAsyncInfo felület, ha feladatokat használ az UWP-alkalmazásban.

_TaskOptions
A feladat opciói.

_Feladat
A létrehozandó feladat.

Visszaadott érték

Egy új típusú feladat, amelyet -ből következtettek.

Megjegyzések

Az első túlterhelés úgy viselkedik, mint egy feladatkonstruktor, amely egyetlen paramétert vesz igénybe.

A második túlterhelés a megadott lemondási tokent az újonnan létrehozott feladathoz társítja. Ha ezt a túlterhelést használja, nem adhat át egy másik objektumot első paraméterként.

A visszaadott feladat típusa a függvény első paraméteréből következtethető. Ha egy , egy vagy egy funktor, amely vagy típust ad vissza, a létrehozott feladat típusa .

UWP-alkalmazásokban, ha _Param típusa Windows::Foundation::IAsyncOperation<T>^ vagy Windows::Foundation::IAsyncOperationWithProgress<T,P>^, vagy egy olyan funktort, amely bármelyik típust visszaadja, a létrehozott feladat task<T> típusú lesz. Ha _Param típusa Windows::Foundation::IAsyncAction^ vagy Windows::Foundation::IAsyncActionWithProgress<P>^, vagy egy olyan funktor, amely ezen típusok valamelyikét adja vissza, a létrehozott tevékenység task<void> típusú lesz.

Nyomkövetés kikapcsolása

Letiltja a nyomkövetést az egyidejűségi futtatókörnyezetben. Ez a függvény elavult, mert az ETW-nyomkövetés alapértelmezés szerint nincs regisztrálva.

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

Visszaadott érték

Ha a nyomkövetés megfelelően le lett tiltva, a rendszer ad vissza. Ha a nyomkövetést korábban nem kezdeményezték, lesz visszaadva

Engedélyezze a naplózást

Engedélyezi a nyomkövetést az egyidejű futási környezetben. Ez a függvény elavult, mert az ETW-nyomkövetés alapértelmezés szerint be van kapcsolva.

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

Visszaadott érték

Ha a nyomkövetést helyesen kezdeményezték, ad vissza; ellenkező esetben lesz visszaadva.

Ingyenes

Felszabadít egy memóriablokkot, amelyet korábban a metódus foglalt le az Egyidejű futtatókörnyezet gyorsítótárazó alsóerőforrásának.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Paraméterek

_PAllocation
A felszabadítani kívánt metódus által korábban lefoglalt memóriára mutató mutató. Ha a paraméter a értékre van állítva, ez a metódus figyelmen kívül hagyja, és azonnal visszatér.

Megjegyzések

További információért arról, hogy az alkalmazás mely forgatókönyvei számára lehet előnyös a gyorsítótár alallokátor használata, tekintse meg a Feladatütemezőt.

get_ambient_scheduler

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

Visszaadott érték

GetExecutionContextId

A felületet megvalósító végrehajtási környezethez hozzárendelhető egyedi azonosítót ad vissza.

unsigned int __cdecl GetExecutionContextId();

Visszaadott érték

Egy végrehajtási környezet egyedi azonosítója.

Megjegyzések

Ezzel a módszerrel lekérheti a végrehajtási környezet azonosítóját, mielőtt paraméterként átad egy IExecutionContext interfészt a Resource Manager által kínált metódusoknak.

GetOSVersion

Az operációs rendszer verzióját adja vissza.

IResourceManager::OSVersion __cdecl GetOSVersion();

Visszaadott érték

Az operációs rendszert jelképező számbavételi érték.

Megjegyzések

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

GetProcessorCount (Processzorok száma lekérése)

A mögöttes rendszeren lévő hardverszálak számát adja vissza.

unsigned int __cdecl GetProcessorCount();

Visszaadott érték

A hardverszálak száma.

Megjegyzések

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

GetProcessorNodeCount

A mögöttes rendszeren található NUMA-csomópontok vagy processzorcsomagok számát adja vissza.

unsigned int __cdecl GetProcessorNodeCount();

Visszaadott érték

A NUMA-csomópontok vagy processzorcsomagok száma.

Megjegyzések

Ha a rendszer több NUMA-csomópontot tartalmaz, mint a processzorcsomagokat, a rendszer visszaadja a NUMA-csomópontok számát, ellenkező esetben a processzorcsomagok száma lesz visszaadva.

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

SzerezdMegAzÜtemezőAzonosítóját

A felületet megvalósító ütemezőhöz hozzárendelhető egyedi azonosítót ad vissza.

unsigned int __cdecl GetSchedulerId();

Visszaadott érték

Egy egyedi ütemező azonosító.

Megjegyzések

Ezzel a módszerrel beszerezheti az ütemező azonosítóját, mielőtt paraméterként átad egy IScheduler interfészt a Resource Manager által kínált módszerek bármelyikének.

belső_kiosztás_iterátorok

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

Paraméterek

_Ax

_Én

első

utolsó

megszakítási pont

Megszakítási pontot hoz létre a lemondáshoz. Ha egy lemondás folyamatban van abban a környezetben, ahol a függvényt meghívják, ez egy belső kivételt eredményez, amely megszakítja a jelenleg futó párhuzamos munka végrehajtását. Ha a lemondás nincs folyamatban, a függvény nem tesz semmit.

inline void interruption_point();

Megjegyzések

A függvény által dobott belső törlési kivételt nem szabad elkapnia. A kivételt a futtatókörnyezet fogja elkapni és kezelni, és az, hogy elkapjuk, a program rendellenes viselkedését okozhatja.

is_current_task_group_canceláló

Visszaadja annak jelzését, hogy a jelenlegi környezeten belül in-line végrehajtott feladatcsoport éppen aktív lemondási folyamat közepén van-e (vagy hamarosan). Vegye figyelembe, hogy ha jelenleg nincs olyan tevékenységcsoport, amely az aktuális környezetben hajt végre beágyazott végrehajtást, a rendszer ad vissza.

bool __cdecl is_current_task_group_canceling();

Visszaadott érték

, ha az éppen végrehajtott feladatcsoport törlés alatt van, ellenkező esetben.

Megjegyzések

További információ: Lemondási.

választás_megtétele

Egy üzenetküldési blokkot hoz létre egy választható vagy és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

_PScheduleGroup
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik. A használt objektumot az ütemezési csoport feltételezi.

Visszaadott érték

Egy üzenetblokk két vagy több bemeneti forrással.

make_greedy_join

Egy üzenetküldési blokkot hoz létre egy választható vagy és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

_PScheduleGroup
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik. A használt objektumot az ütemezési csoport feltételezi.

Visszaadott érték

Egy üzenetblokk két vagy több bemeneti forrással.

csatlakozás_készítése

Egy üzenetküldési blokkot hoz létre egy választható vagy és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

_PScheduleGroup
Az objektum, amelyen belül a üzenetküldési blokk propagálási feladatának ütemezése történik. A használt objektumot az ütemezési csoport feltételezi.

Visszaadott érték

Egy üzenetblokk két vagy több bemeneti forrással.

feladat_létrehozása

Egy objektum létrehozására szolgáló gyári módszer.

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

Paraméterek

_Funkció
A objektum által képviselt munka végrehajtásához meghívandó függvényobjektum típusa.

_Func
A objektum által képviselt munka végrehajtásához meghívandó függvény. Ez lehet egy lambda funktor, egy függvénymutató, vagy bármely objektum, amely támogatja a függvényhívási operátor egy változatát a következő aláírással: .

Visszaadott érték

Egy objektum.

Megjegyzések

Ez a függvény akkor hasznos, ha lambda kifejezéssel kell létrehoznia egy objektumot, mivel lehetővé teszi az objektum létrehozását anélkül, hogy ismerné a lambda funktor valódi típusát.

parallel_buffered_sort

A megadott tartomány elemeit egy nem csökkenő sorrendbe rendezi, vagy egy bináris predikátum által megadott rendezési feltételnek megfelelően, párhuzamosan. Ez a függvény szemantikailag hasonlít a , mivel összehasonlításalapú, instabil, helyben rendezés, kivéve, hogy további helyet igényel, és a rendezendő elemek alapértelmezett inicializálását igényli.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Allokátor
A C++ standard kódtár-kompatibilis memóriaelosztó típusa.

_Funkció
A bináris összehasonlító típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Alloc
C++ memóriakiosztó, amely kompatibilis a standard könyvtárral.

_Func
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az összehasonlítási feltételt, amelyet a rendezés egymást követő elemeinek teljesítenie kell. A bináris predikátumok két argumentumot használnak, és ad vissza, ha teljesülnek, és , ha nem teljesülnek. Ennek az összehasonlító függvénynek szigorúan gyenge sorrendet kell szabnia a sorozat elemeinek párjaira.

_Chunk_size
Egy adattömb mimimummérete, amely két részre lesz felosztva a párhuzamos végrehajtáshoz.

Megjegyzések

Minden túlterheléshez szükség van további helyre, ahol a rendezendő elemek száma, pedig az elem típusa. A legtöbb esetben a parallel_buffered_sort jobb teljesítményt mutat, mint a parallel_sort, és ezt érdemes használni, ha rendelkezésre áll elegendő memória.

Ha nem ad meg egy bináris összehasonlítót, a lesz alapértelmezettként használva, amely megköveteli, hogy az elem típusának támogatnia kell az operátort .

Ha nem ad meg kiosztótípust vagy -példányt, a rendszer a C++ standard kódtár memóriaelosztóját használja a puffer lefoglalásához.

Az algoritmus két adattömbre osztja a bemeneti tartományt, és egymás után két résztömbre osztja az egyes adattömböket a párhuzamos végrehajtáshoz. Az opcionális argumentum használható annak jelzésére, hogy az algoritmusnak sorozatosan kell kezelnie a méretű adattömböket.

parallel_for

az indexek tartományán halad át, és egy felhasználó által megadott függvényt hajt végre az egyes iterációkban, párhuzamosan.

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

Paraméterek

_Index_típus
Az iterációhoz használt index típusa.

_Funkció
Az egyes iterációkban végrehajtandó függvény típusa.

_Particionáló
A megadott tartomány particionálásához használt particionáló típusa.

első
Az iteráció első indexe.

utolsó
Az utolsóként szereplő indexet követő első index az iterációban.

_Lépés
Az az érték, amellyel és közötti iterálás során lépkedhet. A lépésnek pozitívnak kell lennie. invalid_argument akkor lesz eldobva, ha a lépés 1-nél kisebb.

_Func
Az egyes iterációkban végrehajtandó függvény. Ez lehet lambda kifejezés, függvénymutató vagy bármely objektum, amely támogatja a függvényhívási operátor egy verzióját a függvény szignatúrával .

_Rész
A particionáló objektumra mutató hivatkozás. Az argumentum lehet az egyik auto_partitioner, static_partitioner, simple_partitioner vagy affinity_partitioner Ha affinity_partitioner objektumot használ, a hivatkozásnak nem konstans l-érték referenciának kell lennie, hogy az algoritmus tárolhassa az állapotot a jövőbeli ciklusok újbóli használatához.

Megjegyzések

További információ: Párhuzamos algoritmusok.

parallel_for_each

egy megadott függvényt alkalmaz egy tartomány minden elemére, párhuzamosan. Szemantikailag megegyezik a névtér függvényével, azzal a különbségekkel, hogy az elemek iterációja párhuzamosan történik, és az iteráció sorrendje meghatározatlan. Az argumentumnak támogatnia kell egy függvényhívó operátort, , amelyben a paraméter az iterált tároló elemtípusa.

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

Paraméterek

_Iterator
A tárolón keresztüli iteráláshoz használt iterátor típusa.

_Funkció
A tartomány egyes elemeire alkalmazott függvény típusa.

_Particionáló
első
Egy iterátor, amely a párhuzamos iteráció első elemének pozícióját kezeli.

utolsó
Egy iterátor, amely a párhuzamos iteráció során a záró elem utáni pozíciót kezeli.

_Func
A tartomány egyes elemeire alkalmazott, felhasználó által definiált függvényobjektum.

Megjegyzések

auto_partitioner explicit particionáló nélkül használjuk a túlterheléshez.

A véletlenszerű hozzáférést nem támogató iterátorok esetében csak auto_partitioner támogatott.

További információ: Párhuzamos algoritmusok.

párhuzamos_felhívás

Párhuzamosan hajtja végre a paraméterekként megadott függvényobjektumokat, és megvárja, amíg befejeződnek a végrehajtások. Minden függvényobjektum lehet lambda kifejezés, egy függvénymutató vagy bármely olyan objektum, amely támogatja a függvényhívási operátort a szignatúrájú .

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

Paraméterek

_Function1
Az első párhuzamosan végrehajtandó függvényobjektum típusa.

_Function2
A párhuzamosan végrehajtandó második függvényobjektum típusa.

_Function3
A párhuzamosan végrehajtandó harmadik függvényobjektum típusa.

_Function4
A párhuzamosan végrehajtandó negyedik függvényobjektum típusa.

_Function5
A párhuzamosan végrehajtandó ötödik függvényobjektum típusa.

_Function6
A párhuzamosan végrehajtandó hatodik függvényobjektum típusa.

_Function7
A párhuzamosan végrehajtandó hetedik függvényobjektum típusa.

_Function8
A párhuzamosan végrehajtandó nyolcadik függvényobjektum típusa.

_Function9
A párhuzamosan végrehajtandó kilencedik függvényobjektum típusa.

_Function10
A párhuzamosan végrehajtandó tizedik függvényobjektum típusa.

_Func1
Az első párhuzamosan végrehajtandó függvényobjektum.

_Func2
A második, párhuzamosan végrehajtandó függvényobjektum.

_Func3
A harmadik, párhuzamosan végrehajtandó függvényobjektum.

_Func4
A párhuzamosan végrehajtandó negyedik függvényobjektum.

_Func5
A párhuzamosan végrehajtandó ötödik függvényobjektum.

_Func6
A hatodik, párhuzamosan végrehajtandó függvényobjektum.

_Func7
A hetedik, párhuzamosan végrehajtandó függvényobjektum.

_Func8
A párhuzamosan végrehajtandó nyolcadik függvényobjektum.

_Func9
A párhuzamosan végrehajtandó kilencedik függvényobjektum.

_Func10
A párhuzamosan végrehajtandó tizedik függvényobjektum.

Megjegyzések

Vegye figyelembe, hogy a paraméterekként megadott függvényobjektumok közül egy vagy több inline módon is végrehajtható a hívókörnyezetben.

Ha a függvény paraméterként átadott egy vagy több függvényobjektum kivételt jelez, a futtatókörnyezet kiválaszt egy ilyen kivételt, és propagálja azt a hívásából.

További információ: Párhuzamos algoritmusok.

parallel_radixsort

Egy adott tartomány elemeit nem csökkenő sorrendbe rendezi radix rendezési algoritmus használatával. Ez egy stabil rendezési függvény, amely olyan kivetítési függvényt igényel, amely a projektelemeket aláíratlan egész számszerű kulcsokká rendezheti. A rendezés alatt álló elemekhez alapértelmezett inicializálás szükséges.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Allokátor
A C++ standard kódtár-kompatibilis memóriaelosztó típusa.

_Funkció
A vetítési függvény típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Alloc
C++ memóriakiosztó, amely kompatibilis a standard könyvtárral.

_Proj_func
Felhasználó által definiált kivetítőfüggvény-objektum, amely egy elemet integrál értékké alakít át.

_Chunk_size
Egy adattömb mimimummérete, amely két részre lesz felosztva a párhuzamos végrehajtáshoz.

Megjegyzések

Minden túlterheléshez szükség van további helyre, ahol a rendezendő elemek száma, pedig az elem típusa. Az aláírási rendelkező unary projection funktornak kulcs visszaadásához kell megadnia egy elemet, ahol az elem típusa, pedig egy aláíratlan egész szám típusú.

Ha nem ad meg vetítési függvényt, a rendszer egy alapértelmezett vetítési függvényt használ, amely egyszerűen visszaadja az elemet az integráltípusokhoz. A függvény fordítása sikertelen lesz vetítési függvény hiányában, ha az elem nem egész típusú.

Ha nem ad meg kiosztótípust vagy -példányt, a rendszer a C++ standard kódtár memóriaelosztóját használja a puffer lefoglalásához.

parallel_reduce

Kiszámítja az összes elem összegét egy adott tartományban az egymást követő részleges összegek kiszámításával, vagy párhuzamosan kiszámítja az egymást követő részleges eredményeket egy megadott, az összeadástól eltérő bináris művelet alkalmazásával. szemantikailag hasonlít a , azzal a kivételrel, hogy a bináris műveletnek asszociatívnak kell lennie, és a kezdeti érték helyett identitásértéket igényel.

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

Paraméterek

_Forward_iterator
A bemeneti tartomány iterátortípusa.

_Sym_reduce_fun
A szimmetrikus redukciós függvény típusa. Ennek egy függvénytípusnak kell lennie aláírással, ahol a _Reduce_type megegyezik az identitástípussal, valamint a csökkentés eredményének típusával. A harmadik túlterhelés esetén ennek konzisztensnek kell lennie a kimeneti típusával.

_Reduce_type
Az a típus, amelyre a bemenet csökken, amely eltérhet a bemeneti elem típusától. A visszatérési érték és az identitás értéke ilyen típusú lesz.

_Range_reduce_fun
A tartománycsökkentési függvény típusa. Ez egy olyan függvénytípus kell legyen, melynek aláírása , _Reduce_type ugyanaz, mint az identitástípus és a csökkentés eredménytípusa.

_Kezdődik
Egy bemeneti iterátor, amely a csökkenteni kívánt tartomány első elemét kezeli.

_Vég
Egy bemeneti iterátor, amely a csökkenteni kívánt tartomány utolsó elemétől egy pozícióban lévő elemet kezeli.

_Azonosság
Az identitásérték azonos típusú, mint a csökkentés eredménytípusa, valamint az iterátor az első és a második túlterhelés esetén. A harmadik túlterhelés esetén az identitásértéknek ugyanolyan típusúnak kell lennie, mint a redukció eredménytípusa, de eltérhet az iterátor egy adott jellemzőjét jelképező -tól. Megfelelő értékkel kell rendelkeznie, hogy ha a tartománycsökkentési operátor , a egy elem tartományára és az identitásértékre alkalmazzuk, akkor úgy viselkedjen, mint az érték típusának típusból az identitástípusba való típuskonverziója.

_Sym_fun
A csökkentés második szakaszában használt szimmetrikus függvény. További információért tekintse meg a Megjegyzések című témakört.

_Range_fun
A csökkentés első fázisában használt függvény. További információért tekintse meg a Megjegyzések című témakört.

Visszaadott érték

A csökkentés eredménye.

Megjegyzések

Párhuzamos csökkentés végrehajtásához a függvény a tartományt adattömbökre osztja az alapul szolgáló ütemező számára elérhető feldolgozók száma alapján. A csökkentés két fázisban történik, az első fázis az egyes adattömbökön belül végez csökkentést, a második fázis pedig az egyes adattömbök részleges eredményei közötti csökkentést.

Az első túlterheléshez az iterátor , azonosnak kell lennie az identitásérték típusával és a csökkentési eredmény típusával. A T típusú elemnek biztosítania kell az operátort az egyes szegmensek elemeinek csökkentésére. Ugyanez az operátor a második fázisban is használatos.

A második túlterheléshez az is szükséges, hogy az iterátor azonos legyen az identitásérték típusával és a csökkentési eredmény típusával. A megadott bináris operátor mindkét csökkentési fázisban használatos, az identitás értéke pedig az első fázis kezdeti értéke.

A harmadik túlterhelés esetén az identitásérték típusának meg kell egyeznie a csökkentési eredmény típusával, de az iterátor eltérhetnek a kettőtől. A tartománycsökkentési függvény az első fázisban az identitásértéket használja kezdeti értékként, a bináris függvény pedig a második fázisban lévő aleredményekre lesz alkalmazva.

parallel_sort

A megadott tartomány elemeit egy nem csökkenő sorrendbe rendezi, vagy egy bináris predikátum által megadott rendezési feltételnek megfelelően, párhuzamosan. Ez a függvény szemantikailag hasonlít a -re, mivel ez egy összehasonlítás-alapú, instabil, helyben végrehajtott rendezés.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Funkció
A bináris összehasonlító funktor típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Chunk_size
A párhuzamos végrehajtáshoz két részre felosztott adattömb minimális mérete.

Megjegyzések

Az első túlterhelés a bináris összehasonlítót használja.

A második túlterhelt a megadott bináris összehasonlítót használja, amelynek aláírása legyen, ahol a bemeneti tartomány elemeinek típusa.

párhuzamos_átalakítás

Egy megadott függvényobjektumot alkalmaz egy forrástartomány minden elemére vagy két forrástartomány elemeinek párjára, és a függvényobjektum visszatérési értékeit egy céltartományba másolja párhuzamosan. Ez a funkció szemantikailag egyenértékű a .

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

Paraméterek

_Input_iterator1
Az első vagy csak bemeneti iterátor típusa.

_Output_iterator
A kimeneti iterátor típusa.

_Unáris_operátor
A bemeneti tartomány egyes elemein végrehajtandó unary funktor típusa.

_Input_iterator2
A második bemeneti iterátor típusa.

_Bináris_operátor
A bináris funktor típusa, amelyet páronként hajtanak végre a két forrástartomány elemein.

_Particionáló
első1
Egy bemeneti iterátor, amely az első vagy egyetlen működtetni kívánt forrástartomány első elemének pozícióját kezeli.

utolsó1
Egy bemeneti iterátor, amely az első vagy egyetlen forrástartomány utolsó elemén túli pozíciót jelöl.

_Eredmény
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli.

_Unary_op
A forrástartomány egyes elemeire alkalmazott, felhasználó által definiált egyváltozós függvényobjektum.

első2
Egy bemeneti iterátor, amely a második forrástartomány első elemének pozícióját kezeli.

_Binary_op
Egy felhasználó által definiált bináris függvényobjektum, amelyet a rendszer a két forrástartományra párban, előrefelé alkalmaz.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemétől egy korábbi pozíciót kezeli, amely a függvényobjektum által átalakított kimeneti elemeket fogadja.

Megjegyzések

auto_partitioner explicit particionáló argumentum nélkül használható a túlterhelésekhez.

A véletlenszerű hozzáférést nem támogató iterátorok esetében csak auto_partitioner támogatott.

Az argumentumot használó túlterhelések átalakítják a bemeneti tartomány elemeit úgy, hogy a kimeneti tartományt eredményezik, minden egyes elemre alkalmazva az egyváltozós funktort. támogatnia kell a függvényhívási operátort a szignatúrával, ahol az iterált tartomány értéktípusa.

Az argumentumot használó túlterhelések átalakítanak két bemeneti tartományt a kimeneti tartományba úgy, hogy a bináris funktort az első bemeneti tartomány egyik elemére, a második bemeneti tartomány egyik elemére alkalmazza. támogatnia kell a hívás operátort aláírással , ahol és a két bemeneti iterátor értéktípusai.

További információ: Párhuzamos algoritmusok.

fogad

Általános fogadási implementáció, amely lehetővé teszi, hogy a környezet pontosan egy forrásból várja meg az adatokat, és szűrje az elfogadott értékeket.

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

Paraméterek

T
A teheradat típusa.

_Src
Mutató vagy hivatkozás arra a forrásra, amelytől az adatok várhatók.

_Időkorlát
Az az adatokhoz tartozó maximális idő ezredmásodpercben, amelyet a metódus figyelembe vesz.

_Filter_proc
Szűrőfüggvény, amely meghatározza, hogy az üzeneteket el kell-e fogadni.

Visszaadott érték

A forrásból származó, hasznos teher típusú érték.

Megjegyzések

Amennyiben a paraméter értéke nem egyezik meg az állandóval, a rendszer operation_timed_out kivételt dob, ha a megadott idő lejár azelőtt, hogy üzenet érkezne. Ha nulla hosszúságú időtúllépést szeretne, a try_receive függvényt kell használnia, nem pedig (nulla) időtúllépéssel meghívni , mivel hatékonyabb, és nem ad kivételeket az időtúllépésekre.

További információ: Üzenetátadási függvények.

futás_megszakítási_tokennel

Egy függvényobjektumot azonnal és szinkron módon hajt végre egy adott lemondási jogkivonat kontextusában.

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

Paraméterek

_Funkció
A meghívandó függvényobjektum típusa.

_Func
A végrehajtandó függvényobjektum. Ennek az objektumnak támogatnia kell a függvényhívási operátort a void(void) aláírással.

_Ct
A függvényobjektum implicit törlését vezérlő törlési token. Használja a , ha úgy szeretné végrehajtani a függvényt, hogy nincs lehetőség a szülő tevékenységcsoport implicit visszavonására.

Megjegyzések

A függvényobjektum megszakítási pontjai a megszakításakor aktiválódnak. Az explicit token elkülöníti ezt a a szülői lemondástól, ha a szülő másik tokenje van, vagy nincs tokene.

küld

Szinkron küldési művelet, amely megvárja, amíg a cél elfogadja vagy elutasítja az üzenetet.

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

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

Paraméterek

T
A teheradat típusa.

_Trg
Mutató vagy hivatkozás arra a célra, amelyre az adatokat küldi.

_Adat
Hivatkozás az elküldendő adatokra.

Visszaadott érték

, ha az üzenetet elfogadták, ellenkező esetben.

Megjegyzések

További információ: Üzenetátadási függvények.

set_ambient_scheduler

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

Paraméterek

_Táblázat
A beállítani kívánt környezeti ütemező.

Beállítás_feladat_végrehajtási_erőforrások

Az egyidejűségi futtatókörnyezet belső feldolgozói szálai által használt végrehajtási erőforrásokat a megadott affinitási csoportra korlátozza.

Ezt a metódust csak a Resource Manager létrehozása előtt vagy két Resource Manager élettartam között lehet meghívni. Többször is meghívható, amíg a Resource Manager nem létezik a meghívás időpontjában. Az affinitási korlát beállítása után a metódus következő érvényes hívásáig érvényben marad.

A megadott affinitási maszknak nem kell a folyamat affinitási maszkjának egy részhalmazának lennie. A folyamat affinitása szükség esetén frissül.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Paraméterek

_ProcessAffinityMask
Az affinitási maszk, amelybe az egyidejűségi futtatókörnyezeti feldolgozói szálakat korlátozni kell. Ezt a módszert csak akkor használja 64-nél több hardverszállal rendelkező rendszeren, ha az egyidejűségi futtatókörnyezetet az aktuális processzorcsoport egy részhalmazára szeretné korlátozni. Általában annak a metódusnak a verzióját kell használnia, amely paraméterként fogadja el a csoport affinitásainak tömbét, hogy korlátozza a 64-nél több hardverszállal rendelkező gépek affinitását.

szám
A paraméter által megadott tömb bejegyzéseinek száma.

_PGroupAffinity
bejegyzések tömbje.

Megjegyzések

A metódus invalid_operation kivételt ad, ha a meghíváskor Resource Manager van jelen, és invalid_argument kivételt, ha az affinitás üres erőforráskészletet eredményez.

A metódus azon verziója, amely paraméterként csoport affinitásokat tartalmazó tömböt használ, csak olyan operációs rendszereken használható, amelyek Windows 7 vagy újabb verziójúak. Ellenkező esetben egy invalid_operation kivételt dob a rendszer.

Ha programozott módon módosítja a folyamat affinitását a metódus meghívása után, az nem fogja okozni, hogy a Resource Manager újra kiértékelje a korlátozott affinitást. Ezért a metódus meghívása előtt minden módosítást el kell végezni a folyamat affinitásán.

cserél

Két objektum elemeinek cseréje.

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

Paraméterek

T
Az egyidejű vektorokban tárolt elemek adattípusa.

_Ax
Az egyidejű vektorok kiosztó típusa.

_Egy
Az egyidejű vektor, amelynek elemeit az egyidejű vektor elemeivel kell kicserélni.

_B
Az egyidejű vektor, amely biztosítja a felcserélni kívánt elemeket, vagy az a vektor, amelynek elemeit az egyidejű vektor elemeivel kell kicserélni.

Megjegyzések

A sablonfüggvény egy olyan algoritmus, amely a tárolóosztályra a tagfüggvény végrehajtására specializálódott. concurrent_vector::swap(). Ezek a függvénysablonok részleges sorrendjének példái a fordító által. Ha a sablonfüggvények túlterheltek oly módon, hogy a sablon és a függvényhívás egyezése nem egyedi, akkor a fordító kiválasztja a sablonfüggvény leg specializáltabb verzióját. A sablonfüggvény általános verziója az algoritmus osztályban hozzárendelés szerint működik, és lassú művelet. Az egyes tárolók specializált verziója sokkal gyorsabb, mivel közvetlenül a tárolóosztály belső ábrázolásával dolgozik.

Ez a módszer nem egyidejűségbiztos. Ha ezt a metódust meghívja, győződjön meg arról, hogy más szálak nem hajtanak végre műveleteket az egyidejű vektorok egyikén sem.

feladat_a_kivételből

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

Paraméterek

_TaskType

_ExType

_Kivétel

_TaskOptions

Visszaadott érték

feladat_eredményből

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

Paraméterek

_Param

_TaskOptions

Visszaadott érték

Trace_agents_register_name

A megadott nevet társítja az üzenetblokkhoz vagy -ügynökhöz az ETW-nyomkövetésben.

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

Paraméterek

T
Az objektum típusa. Ez általában üzenetblokk vagy ügynök.

_PObject
A nyomkövetésben névvel ellátott üzenetblokkra vagy ügynökre mutató hivatkozás.

_Név
Az adott objektum neve.

próbál_átvenni

Általános kipróbálási implementáció, amely lehetővé teszi, hogy a környezet pontosan egy forrásból keressen adatokat, és szűrje az elfogadott értékeket. Ha az adatok nem állnak készen, a metódus ad vissza.

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

Paraméterek

T
A payload típusa

_Src
Mutató vagy hivatkozás arra a forrásra, amelytől az adatok várhatók.

_érték
Hivatkozás arra a helyre, ahol az eredmény el lesz helyezve.

_Filter_proc
Szűrőfüggvény, amely meghatározza, hogy az üzeneteket el kell-e fogadni.

Visszaadott érték

Egy érték, amely azt jelzi, hogy -ben el lett-e helyezve egy teheradat.

Megjegyzések

További információ: Üzenetátadási függvények.

várj

Egy adott ideig szünetelteti az aktuális környezetet.

void __cdecl wait(unsigned int _Milliseconds);

Paraméterek

Ezredmásodperc
Az aktuális környezethez tartozó ezredmásodpercek számát fel kell függeszteni. Ha a paraméter a értékre van állítva, a folytatás előtt az aktuális környezetnek végrehajtást kell eredményeznie más futtatható környezetekben.

Megjegyzések

Ha ezt a metódust concurrency runtime scheduler-környezetben hívják meg, az ütemező egy másik környezetet fog találni a mögöttes erőforráson való futtatáshoz. Mivel az ütemező együttműködő jellegű, ez a környezetállapot nem tud pontosan a megadott milliszekundum szerint folytatódni. Ha az ütemező más, az ütemezőnek nem együttműködő feladatok végrehajtásával van elfoglalva, a várakozási idő határozatlan lehet.

when_all

Létrehoz egy feladatot, amely sikeresen befejeződik, ha az argumentumként megadott összes tevékenység sikeresen befejeződött.

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

Paraméterek

_Iterator
A bemeneti iterátor típusa.

_Kezdődik
Az eredményül kapott tevékenységhez egyesítendő elemek tartományának első elemének pozíciója.

_Vég
Az első elem pozíciója az eredményül kapott tevékenységhez kombinálandó elemek tartományán túl.

_TaskOptions
A objektum.

Visszaadott érték

Olyan feladat, amely sikeresen befejeződött, amikor az összes bemeneti tevékenység sikeresen befejeződött. Ha a bemeneti tevékenységek típusúak, a függvény kimenete egy lesz. Ha a bemeneti tevékenységek típusa a kimeneti tevékenység is lesz.

Megjegyzések

egy nem blokkoló függvény, amely ennek eredményeként hoz létre. Az task::wait-tal ellentétben, ez a függvény biztonságosan meghívható egy UWP-alkalmazás ASTA (Application STA) szálán.

Ha az egyik feladatot törlik, vagy kivételt vet ki, a visszaadott feladat korán, törölt állapotban fejeződik be, és a kivétel dobva lesz, ha meghívja a feladat::get vagy az adott feladaton.

További információ: Feladat-párhuzamosság.

amikor_bármelyik

Létrehoz egy feladatot, amely sikeresen befejeződik, ha az argumentumként megadott tevékenységek bármelyike sikeresen befejeződik.

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

Paraméterek

_Iterator
A bemeneti iterátor típusa.

_Kezdődik
Az eredményül kapott tevékenységhez egyesítendő elemek tartományának első elemének pozíciója.

_Vég
Az első elem pozíciója az eredményül kapott tevékenységhez kombinálandó elemek tartományán túl.

_TaskOptions
_CancellationToken
A visszaadott feladat törlését vezérlő törlési token. Ha nem ad meg törlési tokent, a létrejövő feladat megkapja annak a feladatnak a törlési tokenjét, amely miatt a folyamat befejeződik.

Visszaadott érték

Olyan feladat, amely sikeresen befejeződik, ha a bemeneti tevékenységek bármelyike sikeresen befejeződött. Ha a bemeneti tevékenységek típusúak, a függvény kimenete egy lesz, ahol a pár első eleme a befejező tevékenység eredménye, a második elem pedig a befejezett tevékenység indexe. Ha a bemeneti tevékenységek típusa a kimenet egy , ahol az eredmény a befejező tevékenység indexe.

Megjegyzések

egy nem blokkoló függvény, amely ennek eredményeként hoz létre. Az task::wait-tal ellentétben, ez a függvény biztonságosan meghívható egy UWP-alkalmazás ASTA (Application STA) szálán.

További információ: Feladat-párhuzamosság.

Lásd még:

egyidejű névtér

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-03-06