コンカレンシー名前空間の関数

名前空間では、次の関数を使用できます。

Alloc

コンカレンシー ランタイムのキャッシュ サブアロケータから、指定したサイズのメモリ ブロックを割り当てます。

void* __cdecl Alloc(size_t _NumBytes);

パラメーター

_NumBytes
割り当てるメモリのバイト数。

戻り値

新しく割り当てられたメモリへのポインター。

解説

アプリケーションでキャッシュ サブアロケータを活用できるシナリオの詳細については、タスク スケジューラに関するページを参照してください。

アセンド

ターゲット ブロックにデータを反映するタスクをスケジュールする非同期送信操作です。

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

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

パラメーター

T
送信するデータの型。

_Trg
データの送信先となるターゲットへのポインターまたは参照。

_データ
送信するデータへの参照。

戻り値

メソッドが戻る前にメッセージが受け入れられた場合は 。それ以外の場合は 。

解説

詳細については、「メッセージ パッシング関数」を参照してください。

現在のタスクをキャンセル

現在実行中のタスクを取り消します。 この関数は、タスクの実行を中止して 状態に遷移させるために、タスクの本体から呼び出すことができます。

の本体以外では、この関数を呼び出すシナリオはサポートされません。 これを行うと、アプリケーションのクラッシュや無応答など、定義されていない動作が発生します。

inline __declspec(noreturn) void __cdecl cancel_current_task();

クリア

同時実行キューをクリアし、現在エンキューされているすべての要素を破棄します。 このメソッドはコンカレンシー セーフではありません。

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

パラメーター

T

_Ax

create_async

ユーザーが指定したラムダまたは関数オブジェクトに基づいて、Windows ランタイム非同期コンストラクトを作成します。 の戻り値の型は、、、、 のいずれかで、メソッドに渡されるラムダのシグネチャに基づいています。

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

パラメーター

_機能
タイプ

_Func
Windows ランタイム非同期コンストラクトの作成元となるラムダまたは関数オブジェクト。

戻り値

IAsyncAction^、IAsyncActionWithProgressTProgress^、IAsyncOperationTResult^、または IAsyncOperationWithProgressTResult, TProgress^ で表される非同期コンストラクト。 返されるインターフェイスは、関数に渡されるラムダのシグネチャによって異なります。

解説

ラムダの戻り値の型によって、構造がアクションであるか操作であるかが判別されます。

ラムダが void を返すと、アクションが作成されます。 ラムダが型 の結果を返すと、TResult の操作が作成されます。

ラムダは、それ自体の中に非同期作業をカプセル化する を返すか、非同期作業を表すタスクのチェーンの継続である場合もあります。 この場合、ラムダはインラインで実行されます。タスクが非同期的に実行されるためです。ラムダの戻り値の型は、 によって返される非同期構造を生成する際に解除されます。 これは、ラムダが taskvoid を返すとアクションが作成され、ラムダが taskTResult を返すと TResult の操作が作成されることを意味します。

ラムダは、引数を 0 個、1 個、または 2 個受け取ることができます。 有効な引数は と です。これらを両方とも使用する場合は、この順序で指定してください。 ラムダで引数を使用しないと、進行状況の報告機能を持たない非同期構造が作成されます。 ラムダで progress_reporterTProgress を使用すると、 によって非同期コンストラクトが返されます。この非同期コンストラクトでは、progress_reporter オブジェクトの メソッドが呼び出されるたびに、型 TProgress の進行状況がレポートされます。 cancellation_token を使用するラムダでは、そのトークンを利用して取り消しを確認する場合があります。また、作成されるタスクにこのトークンを渡す場合もあります。これにより、非同期構造を取り消すと、それらのタスクも取り消されます。

ラムダまたは関数オブジェクトの本体が結果 (タスクではなくTResult) を返す場合、ラムダは、ランタイムが暗黙的に作成するタスクのコンテキストで、MTA プロセス内で非同期的に実行されます。 のメソッドにより、暗黙のタスクが取り消されます。

ラムダ式の本体がタスクを返す場合、ラムダはインラインで実行され、 型の引数を受け取るようにラムダ式を宣言することで、ラムダ内で作成したタスクにキャンセル・トークンを渡してそのタスクの取り消しをトリガーできます。 また、トークンで メソッドを使用して、生成された非同期操作またはアクションで を呼び出すときにランタイムがコールバックを呼び出すようにすることもできます。

この関数は、Windows ランタイム アプリでのみ使用できます。

CreateResourceManager

コンカレンシー ランタイムのResource Managerのシングルトン インスタンスを表すインターフェイスを返します。 Resource Managerは、相互に連携するスケジューラにリソースを割り当てる役割を担います。

IResourceManager* __cdecl CreateResourceManager();

戻り値

インターフェイスです。

解説

このメソッドを複数回呼び出すと、Resource Managerの同じインスタンスが返されます。 メソッドの各呼び出しは、Resource Managerの参照カウントをインクリメントし、スケジューラがResource Managerとの通信を完了したときに、IResourceManager::Release メソッドの呼び出しと一致する必要があります。

オペレーティングシステムがConcurrency Runtimeによってサポートされていない場合、unsupported_osがスローされます。

タスクを作成する

PPL task オブジェクトを作成します。 は、タスク コンストラクターを使用した任意の場所で使用できます。 タスクの作成中に キーワードが使用できるようになるため、これは参考用として用意されています。

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

パラメーター

T
パラメーターの型。これに基づいてタスクが構築されます。

_ReturnType
タイプ

_Param
パラメーター。これに基づいてタスクが構築されます。 UWP アプリでタスクを使用している場合は、ラムダ または関数オブジェクト、task_completion_event オブジェクト、別の task オブジェクト、または Windows::Foundation::IAsyncInfo インターフェイスを使用できます。

_TaskOptions
タスクオプション。

_タスク
作成するタスクです。

戻り値

型 の新しいタスク。 から推論されます。

解説

最初のオーバーロードは、単一のパラメーターを受け取るタスク コンストラクターのように動作します。

2 番目のオーバーロードは、新しく作成されたタスクで指定されたキャンセル トークンを関連付けます。 このオーバーロードを使用すると、最初のパラメーターとして別の オブジェクトを渡すことができません。

返されたタスクの種類は、関数の最初のパラメーターから推測されます。 が 、、または型 か型 を返すファンクタの場合、作成されたタスクの型は です。

UWP アプリで、_Param が Windows::Foundation::IAsyncOperation<T>^ または Windows::Foundation::IAsyncOperationWithProgress<T,P>^, または、これらの型のいずれかを返すファンクタは、作成されたタスクの型は task<T> になります。 _Param の型が Windows::Foundation::IAsyncAction^ または Windows::Foundation::IAsyncActionWithProgress<P>^ の場合、またはこれらの型のいずれかを返すファンクタの場合、作成されたタスクの型は task<void> になります。

トレースを無効化

コンカレンシー ランタイムでのトレースを無効にします。 この関数は、ETW トレースが既定で未登録であるため非推奨とされます。

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

戻り値

トレースが適切に無効化されている場合は、 が返されます。 トレースが以前に開始されていない場合は、 が返されます

トレースを有効化する

コンカレンシー ランタイムでトレースを有効にします。 この関数は、ETW トレースが既定でオンであるため非推奨とされます。

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

戻り値

トレースが適切に開始された場合は、 が返されます。それ以外の場合は が返されます。

Free

以前に メソッドによってコンカレンシー ランタイムのキャッシュ サブアロケータに割り当てられたメモリ ブロックを解放します。

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

パラメーター

_PAllocation
以前に メソッドによって割り当てられた解放するメモリへのポインター。 パラメーターの値が に設定されている場合、このメソッドはそれを無視してすぐに制御を戻します。

解説

アプリケーションでキャッシュ サブアロケータを活用できるシナリオの詳細については、タスク スケジューラに関するページを参照してください。

get_ambient_scheduler

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

戻り値

GetExecutionContextId

インターフェイスを実装する実行コンテキストに割り当てることのできる一意識別子を返します。

unsigned int __cdecl GetExecutionContextId();

戻り値

実行コンテキストの一意識別子。

解説

Resource Managerによって提供されるメソッドのいずれかにパラメーターとして IExecutionContext インターフェイスを渡す前に、このメソッドを使用して実行コンテキストの識別子を取得します。

GetOSVersion

オペレーティング システムのバージョンを返します。

IResourceManager::OSVersion __cdecl GetOSVersion();

戻り値

オペレーティング システムを表す列挙値。

解説

オペレーティングシステムがConcurrency Runtimeによってサポートされていない場合、unsupported_osがスローされます。

GetProcessorCount

基になるシステム上のハードウェア スレッドの数を返します。

unsigned int __cdecl GetProcessorCount();

戻り値

ハードウェア スレッドの数。

解説

オペレーティングシステムがConcurrency Runtimeによってサポートされていない場合、unsupported_osがスローされます。

GetProcessorNodeCount

基になるシステム上の NUMA ノードまたはプロセッサ パッケージの数を返します。

unsigned int __cdecl GetProcessorNodeCount();

戻り値

NUMA ノードまたはプロセッサ パッケージの数。

解説

システムに含まれる NUMA ノードの数がプロセッサ パッケージの数より多い場合は、NUMA ノードの数が返されます。それ以外の場合は、プロセッサ パッケージの数が返されます。

オペレーティングシステムがConcurrency Runtimeによってサポートされていない場合、unsupported_osがスローされます。

スケジューラIDを取得

インターフェイスを実装するスケジューラに割り当てることができる一意の識別子を返します。

unsigned int __cdecl GetSchedulerId();

戻り値

スケジューラのユニーク識別子。

解説

IScheduler インターフェイスをパラメーターとしてResource Managerによって提供されるメソッドのいずれかに渡す前に、スケジューラの識別子を取得するには、このメソッドを使用します。

internal_assign_iterators

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

パラメーター

T

_Ax

_I

まずは

最後

中断点

中断用のキャンセルポイントを作成します。 この関数が呼び出されるコンテキストで取り消しが進行中の場合、現在実行中の並列処理を中止する内部例外がスローされます。 取り消しが進行中でない場合は、何も実行されません。

inline void interruption_point();

解説

関数によってスローされる内部キャンセル例外をキャッチしないでください。 この例外はランタイムによってキャッチおよび処理されるため、これをキャッチするとプログラムの動作が異常になることがあります。

タスクグループがキャンセル中か確認중

現在のコンテキストで現在インラインで実行されているタスク グループがアクティブなキャンセル処理中である (または間もなくキャンセル処理が開始される) かどうかを示す値を返します。 現在のコンテキストで現在インラインで実行されているタスク グループが存在しない場合は、 が返されます。

bool __cdecl is_current_task_group_canceling();

戻り値

現在実行中のタスク グループがキャンセルされる場合は 。それ以外の場合は 。

解説

詳細は、キャンセルを参照してください。

選択を行う

オプションの や 、および 2 つ以上の入力ソースから メッセージング ブロックを構築します。

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

パラメーター

T1
1 番目のソースにおけるメッセージブロックの種類。

T2
2 番目のソースのメッセージブロック型。

_PScheduler
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_項目
その他のソース。

_PScheduleGroup
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。 使用される オブジェクトは、スケジュール グループによって暗黙的に指定されます。

戻り値

2 個またはそれ以上の入力ソースを持つ メッセージ ブロック。

make_greedy_join

オプションの や 、および 2 つ以上の入力ソースから メッセージング ブロックを構築します。

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

パラメーター

T1
1 番目のソースにおけるメッセージブロックの種類。

T2
2 番目のソースのメッセージブロック型。

_PScheduler
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_項目
その他のソース。

_PScheduleGroup
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。 使用される オブジェクトは、スケジュール グループによって暗黙的に指定されます。

戻り値

2 個またはそれ以上の入力ソースを持つ メッセージ ブロック。

make_join

オプションの や 、および 2 つ以上の入力ソースから メッセージング ブロックを構築します。

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

パラメーター

T1
1 番目のソースにおけるメッセージブロックの種類。

T2
2 番目のソースのメッセージブロック型。

_PScheduler
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_項目
その他のソース。

_PScheduleGroup
その内部で メッセージング ブロックの反映タスクがスケジュールされる オブジェクト。 使用される オブジェクトは、スケジュール グループによって暗黙的に指定されます。

戻り値

2 個またはそれ以上の入力ソースを持つ メッセージ ブロック。

タスク作成

オブジェクトを作成するためのファクトリ メソッドです。

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

パラメーター

_機能
オブジェクトによって表される作業を実行するために呼び出される関数オブジェクトの型。

_Func
オブジェクトによって表される作業を実行するために呼び出される関数。 ラムダ ファンクター、関数へのポインター、またはシグネチャ を備えた関数呼び出し演算子のバージョンをサポートする任意のオブジェクトを指定できます。

戻り値

オブジェクト。

解説

この関数は、ラムダ式を使用して オブジェクトを作成する必要がある場合に便利です。これを使用すると、ラムダ ファンクターの実際の型がわからなくてもオブジェクトを作成できるからです。

parallel_buffered_sort

指定された範囲の要素を、降順以外の順序、または二項述語で指定された順序の基準に従って並列に配置します。 この関数は、比較ベースで不安定なインプレース並べ替えという点で と意味が同じです。ただし、 追加スペースが必要で、並べ替えている要素を既定で初期化する必要があります。

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

パラメーター

_Random_iterator
入力範囲の反復子のタイプ。

_アロケーター
C++ 標準ライブラリ互換メモリ アロケーターの型。

_機能
二項比較子の型。

_始める
並べ替えられる範囲内の最初の要素の位置を示すランダム アクセス反復子。

_終わり
並べ替えられる範囲内の最後の要素の 1 つ後ろの位置を示すランダム アクセス反復子。

_Alloc
C++ 標準ライブラリ互換メモリ アロケーターのインスタンス。

_Func
順序内の連続する要素によって満たされるべき比較基準を定義するユーザー定義の述語関数オブジェクト。 二項述語は 2 つの引数を受け取り、条件が満たされている場合は 、満たされていない場合は を返します。 この比較関数は、シーケンス中の要素ペアに厳密な弱順序を課す必要があります。

_Chunk_size
並列実行のために 2 つに分割されるチャンクの最小サイズ。

解説

すべてのオーバーロードには余分に の領域が必要です。ここで は並べ替える要素の数、 は要素の型です。 ほとんどの場合、parallel_buffered_sort を使用すると parallel_sort よりもパフォーマンスが向上するため、使用できるメモリがある場合は、parallel_sort よりもこちらを使用する必要があります。

二項比較子を指定しない場合は、既定値として が使用されます。この場合、要素の型で演算子 を提供する必要があります。

アロケーターの型またはインスタンスを指定しない場合は、バッファーの割り当てには C++ 標準ライブラリ メモリ アロケーター が使用されます。

アルゴリズムによって、入力範囲が 2 つのチャンクに分割され、続いて各チャンクが 2 つのサブチャンクに分割されて並列実行されます。 省略可能な引数 を使用すると、そのアルゴリズムに対して、サイズが のチャンクを順次処理するように指示できます。

parallel_for

は、一定の範囲のインデックスを反復処理し、各反復処理で、ユーザーが指定した関数を並列で実行します。

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

パラメーター

_Index_type
反復処理に使用されるインデックスの型。

_機能
各反復処理で実行される関数の型。

_パーティショナー
指定された範囲を分割するために使用されるパーティショナーの型。

まずは
反復処理に含める最初のインデックス。

最後
反復処理に含める最後のインデックスの 1 つ後ろのインデックス。

_ステップ
から まで反復処理する際のステップの値。 ステップは正の数である必要があります。 ステップが 1 未満の場合は invalid_argument がスローされます。

_Func
各反復処理で実行される関数。 ラムダ式、関数ポインター、またはシグネチャ を備えた関数呼び出し演算子のバージョンをサポートする任意のオブジェクトを指定できます。

_部分
パーティショナー オブジェクトへの参照。 引数には、auto_partitioner、static_partitioner、simple_partitioner、またはaffinity_partitioneraffinity_partitioner オブジェクトを使用する場合、その参照は非 const l 値参照である必要があります。そのため、アルゴリズムは、将来のループを再利用するために状態を格納できます。

解説

詳細については、「並列アルゴリズム」を参照してください。

parallel_for_each

は、指定された関数を範囲内の各要素に並列で適用します。 意味的には 名前空間の 関数と同等ですが、要素に対する反復処理が並列で行われる点、および反復処理の順序が指定されていない点が異なります。 引数 は、 の形式の関数呼び出し演算子をサポートしている必要があります ( パラメーターは反復処理するコンテナーの項目の種類を示します)。

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

パラメーター

_イテレータ
コンテナーを反復処理するために使用される反復子の型。

_機能
範囲内の各要素に適用される関数の型。

_パーティショナー
まずは
並列反復処理に含める最初の要素の位置を示す反復子。

最後
並列反復処理に含める最後の要素の 1 つ後ろの位置を示す反復子。

_Func
範囲内の各要素に適用されるユーザー定義の関数オブジェクト。

_部分
パーティショナー オブジェクトへの参照。 引数には、auto_partitioner、static_partitioner、simple_partitioner、またはaffinity_partitioneraffinity_partitioner オブジェクトを使用する場合、その参照は非 const l 値参照である必要があります。そのため、アルゴリズムは、将来のループを再利用するために状態を格納できます。

解説

auto_partitioner は、明示的なパーティショナーなしにオーバーロードに対して使用されます。

ランダム アクセスをサポートしていない反復子の場合、auto_partitioner のみがサポートされます。

詳細については、「並列アルゴリズム」を参照してください。

parallel_invoke（並列呼び出し）

パラメーターとして渡された関数オブジェクトを並列実行し、実行が完了するまでブロックします。 各関数オブジェクトは、ラムダ式、関数へのポインター、またはシグネチャ を持つ関数呼び出し演算子をサポートするオブジェクトになります。

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

パラメーター

_Function1
並列実行される最初の関数オブジェクトの型。

_Function2
並列実行される 2 番目の関数オブジェクトの型。

_Function3
並列実行される 3 番目の関数オブジェクトの型。

_Function4
並列実行される 4 番目の関数オブジェクトの型。

_Function5
並列実行される 5 番目の関数オブジェクトの型。

_Function6
並列実行される 6 番目の関数オブジェクトの型。

_Function7
並列実行される 7 番目の関数オブジェクトの型。

_Function8
並列実行される 8 番目の関数オブジェクトの型。

_Function9
並列実行される 9 番目の関数オブジェクトの型。

_Function10
並列実行される 10 番目の関数オブジェクトの型。

_Func1
並列実行される最初の関数オブジェクト。

_Func2
並列実行される 2 番目の関数オブジェクト。

_Func3
並列実行される 3 番目の関数オブジェクト。

_Func4
並列実行される 4 番目の関数オブジェクト。

_Func5
並列実行される 5 番目の関数オブジェクト。

_Func6
並列実行される 6 番目の関数オブジェクト。

_Func7
並列実行される 7 番目の関数オブジェクト。

_Func8
並列実行される 8 番目の関数オブジェクト。

_Func9
並列実行される 9 番目の関数オブジェクト。

_Func10
並列実行される 10 番目の関数オブジェクト。

解説

パラメーターとして指定された 1 つ以上の関数オブジェクトは、呼び出し元コンテキストでインライン実行される可能性があることに注意してください。

この関数にパラメーターとして渡された 1 つ以上の関数オブジェクトが例外をスローした場合、ランタイムはそのような例外を 1 つ選択し、 への呼び出しの外部に反映します。

詳細については、「並列アルゴリズム」を参照してください。

parallel_radixsort

基数並べ替えアルゴリズムを使用して、指定された範囲の要素を降順以外の順序で配置します。 これは安定した並べ替え関数で、符号なし整数 (キーなど) に分類されるように要素を投影する投射関数を必要とします。 並べ替えられる要素には既定の初期化が必要です。

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

パラメーター

_Random_iterator
入力範囲の反復子のタイプ。

_アロケーター
C++ 標準ライブラリ互換メモリ アロケーターの型。

_機能
投射関数の型。

_始める
並べ替えられる範囲内の最初の要素の位置を示すランダム アクセス反復子。

_終わり
並べ替えられる範囲内の最後の要素の 1 つ後ろの位置を示すランダム アクセス反復子。

_Alloc
C++ 標準ライブラリ互換メモリ アロケーターのインスタンス。

_Proj_func
要素を整数値に変換するユーザー定義の投射関数オブジェクト。

_Chunk_size
並列実行のために 2 つに分割されるチャンクの最小サイズ。

解説

すべてのオーバーロードには余分に の領域が必要です。ここで は並べ替える要素の数、 は要素の型です。 要素が指定された場合にキーを返すには、シグネチャ を備えた単項投射ファンクターが必要です。ここで、 は要素の型で、 は符号なし整数のような型です。

投射関数を指定しない場合は、単に要素を返す既定の投射関数が整数型に対して使用されます。 投射関数が存在しないときに要素が整数型ではない場合、関数はコンパイルに失敗します。

アロケーターの型またはインスタンスを指定しない場合は、バッファーの割り当てには C++ 標準ライブラリ メモリ アロケーター が使用されます。

アルゴリズムによって、入力範囲が 2 つのチャンクに分割され、続いて各チャンクが 2 つのサブチャンクに分割されて並列実行されます。 省略可能な引数 を使用すると、そのアルゴリズムに対して、サイズが のチャンクを順次処理するように指示できます。

パラレルリデュース (parallel_reduce)

連続する部分的な合計を計算することで、指定された範囲のすべての要素の合計を計算します。または、指定された二項演算を使用して取得した、合計以外の連続する部分的な結果を並列で計算します。 は と意味が同じです。ただし、結合のための二項演算と、初期値ではなく ID 値が必要です。

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

パラメーター

_Forward_iterator
入力範囲の反復子の型。

_Sym_reduce_fun
対称減少関数の型。 これは、シグネチャ を備えた関数型である必要があります。ここで、_Reduce_type は、ID 型、および減少の結果の型と同じです。 3 番目のオーバーロードの場合、これは の出力型と一致している必要があります。

_リデュース_タイプ
入力が変換される型は、入力要素の型とは異なる場合があります。 戻り値と ID 値は、この型になります。

_Range_reduce_fun
範囲減少関数の型。 これは、シグネチャ を備えた関数型である必要があります。ここで、_Reduce_type は、ID 型、および減少の結果の型と同じです。

_始める
減少する範囲内の最初の要素の位置を示す入力反復子。

_終わり
減少する範囲内の最後の要素の 1 つ後ろの位置にある要素を示す入力反復子。

_同一性
ID 値 は、減少の結果の型と同じ型であり、また、1 番目と 2 番目のオーバーロードの反復子の でもあります。 3 番目のオーバーロードの場合、ID 値の型は減少の結果の型と同じ型である必要がありますが、反復子の とは異なる場合があります。 これには、範囲減少演算子 が、 型の 1 つの要素の範囲と ID 値に適用されたときに、 型から ID 型への値の型キャストのように動作するように、適切な値を指定する必要があります。

_Sym_fun
減少の 2 番目に使用される対称関数。 詳細については、「解説」を参照してください。

_Range_fun
減少の最初のフェーズで使用される関数。 詳細については、「解説」を参照してください。

戻り値

減少の結果。

解説

関数は、並列減少を実行するために、基になるスケジューラで使用できるワーカーの数に基づいて、範囲をチャンクに分割します。 減少は 2 つのフェーズで行われます。最初のフェーズでは各チャンク内で減少が実行され、2 番目のフェーズでは各チャンクの部分的な結果の間で減少が実行されます。

最初のオーバーロードでは、反復子の 、 が、ID 値の型および減少の結果の型と同じになる必要があります。 要素の型 T は、演算子 を提供して、各チャンク内の要素を減少させる必要があります。 2 番目のフェーズでも同じ演算子が使用されます。

また、2 番目のオーバーロードでも、反復子の が ID 値の型および減少の結果の型と同じになる必要があります。 指定された 2 項演算子 は両方の減少フェーズで使用され、ID 値は最初のフェーズの初期値として使用されます。

3 番目のオーバーロードでは、ID 値の型は減少の結果の型と同じである必要がありますが、反復子の は両方とは異なる場合があります。 範囲減少関数 は、ID 値を初期値として使用して最初のフェーズで使用され、2 番目のフェーズでは二項関数 がサブ結果に適用されます。

parallel_sort

指定された範囲の要素を、降順以外の順序、または二項述語で指定された順序の基準に従って並列に配置します。 この関数は、比較ベースで不安定なインプレース並べ替えという点で と意味が同じです。

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

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

パラメーター

_Random_iterator
入力範囲の反復子のタイプ。

_機能
二項比較ファンクターの型。

_始める
並べ替えられる範囲内の最初の要素の位置を示すランダム アクセス反復子。

_終わり
並べ替えられる範囲内の最後の要素の 1 つ後ろの位置を示すランダム アクセス反復子。

_Func
順序内の連続する要素によって満たされるべき比較基準を定義するユーザー定義の述語関数オブジェクト。 二項述語は 2 つの引数を受け取り、条件が満たされている場合は 、満たされていない場合は を返します。 この比較関数は、シーケンス中の要素ペアに厳密な弱順序を課す必要があります。

_Chunk_size
並列実行のために 2 つに分割されるチャンクの最小サイズ。

解説

最初のオーバーロードでは、二項比較演算子 が使用されます。

2 番目のオーバーロードでは、シグネチャ を備えている必要がある、指定の二項比較子が使用されます。ここで は入力範囲内の要素の型です。

アルゴリズムによって、入力範囲が 2 つのチャンクに分割され、続いて各チャンクが 2 つのサブチャンクに分割されて並列実行されます。 省略可能な引数 を使用すると、そのアルゴリズムに対して、サイズが のチャンクを順次処理するように指示できます。

並列変換

指定された関数オブジェクトをソース範囲内の各要素、または 2 つのソース範囲内の要素のペアに適用し、関数オブジェクトの戻り値をコピー先の範囲に並列でコピーします。 この関数は、意味的には と同じです。

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

パラメーター

_Input_iterator1
最初または唯一の入力反復子の型。

_Output_iterator
出力反復子の型。

_単項演算子
入力範囲内の各要素に対して実行される単項ファンクターの型。

_Input_iterator2
2 番目の入力反復子の型。

_二項演算子
2 つのソース範囲の要素に対してペアで実行される二項ファンクターの型。

_パーティショナー
first1
演算対象の最初または唯一のソース範囲内の最初の要素の位置を示す入力反復子。

last1
演算対象の最初または唯一のソース範囲内の最後の要素の 1 つ後ろの位置を示す入力反復子。

_結果
ターゲット範囲の最初の要素の位置を示す出力反復子。

_Unary_op
ソース範囲内の各要素に適用されるユーザー定義の単項関数オブジェクト。

_部分
パーティショナー オブジェクトへの参照。 引数には、auto_partitioner、static_partitioner、simple_partitioner、またはaffinity_partitioneraffinity_partitioner オブジェクトを使用する場合、その参照は非 const l 値参照である必要があります。そのため、アルゴリズムは、将来のループを再利用するために状態を格納できます。

first2
操作する 2 番目のソース範囲内の最初の要素の位置を示す入力反復子。

_Binary_op
2 つのソース範囲に対して順方向にペアで適用される、ユーザー定義の二項関数オブジェクト。

戻り値

関数オブジェクトで変換された出力要素を受け取るターゲット範囲の最後の要素の 1 つ後ろの位置を示す出力反復子。

解説

auto_partitioner は、明示的なパーティショナー引数なしに、オーバーロードに対して使用されます。

ランダム アクセスをサポートしていない反復子の場合、auto_partitioner のみがサポートされます。

引数 を受け取るオーバーロードは、入力範囲内の各要素に対して単項ファンクターを適用することで、入力範囲を出力範囲に変換します。 は、シグネチャ を備えた関数呼び出し演算子をサポートする必要があります。ここで、 は反復処理される範囲の値の型です。

引数 を受け取るオーバーロードは、最初の入力範囲の 1 つの要素と 2 番目の入力範囲の 1 つの要素に二項ファンクターを適用することで、2 つの入力範囲を出力範囲に変換します。 は、シグネチャ を備えた関数呼び出し演算子をサポートする必要があります。ここで、、 は 2 つの入力反復子の値の型です。

詳細については、「並列アルゴリズム」を参照してください。

受信

receive の一般的な実装です。これにより、コンテキストで 1 つのソースからのデータを待機し、受け取った値をフィルター処理できます。

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

パラメーター

T
ペイロードタイプ。

_Src
データの要求先であるソースへのポインターまたは参照。

_タイムアウト
メソッドがデータを待機する必要がある最大時間 (ミリ秒単位)。

_Filter_proc
メッセージを受け入れるかどうかを決定するフィルター関数。

戻り値

ソースからの値 (ペイロードの型)。

解説

パラメーター に定数 以外の値がある場合、メッセージを受信する前に指定の時間が経過すると、operation_timed_out 例外がスローされます。 ゼロ長のタイムアウトを設定したい場合は、try_receive 関数を使用する必要があります。これは、 をゼロのタイムアウトで呼び出すよりも効率的で、タイムアウト時に例外がスローされないからです。

詳細については、「メッセージ パッシング関数」を参照してください。

キャンセレーショントークンと共に実行する (run_with_cancellation_token)

関数オブジェクトを、指定されたキャンセル トークンのコンテキストですばやく同期的に実行します。

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

パラメーター

_機能
呼び出される関数オブジェクトの型。

_Func
実行される関数オブジェクト。 このオブジェクトは、void(void) というシグネチャ を備えた関数呼び出し演算子をサポートしている必要があります。

_Ct
関数オブジェクトの暗黙的なキャンセルを制御するキャンセル トークン。 キャンセルされる親タスク グループからの暗黙的なキャンセルの可能性なしに関数を実行する場合は、 を使用します。

解説

がキャンセルされると、関数オブジェクト内の中断ポイントがトリガーされます。 親に別のトークンがあるやトークンがない場合、明示的なトークン によって、この が親のキャンセルから分離されます。

送信

ターゲットがメッセージを受け入れるか拒否するまで待機する同期送信操作です。

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

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

パラメーター

T
ペイロードタイプ。

_Trg
データの送信先となるターゲットへのポインターまたは参照。

_データ
送信するデータへの参照。

戻り値

メッセージが受け入れられた場合は 。それ以外の場合は 。

解説

詳細については、「メッセージ パッシング関数」を参照してください。

set_ambient_scheduler

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

パラメーター

_スケジューラ
設定するアンビエントスケジューラ。

タスク実行リソースの設定

コンカレンシー ランタイムの内部ワーカー スレッドが使用する実行リソースを、指定された関係セットに制限します。

このメソッドは、Resource Managerが作成される前、または 2 つのResource Manager有効期間の間でのみ呼び出すと有効です。 呼び出し時にResource Managerが存在しない限り、複数回呼び出すことができます。 親和性の制限が設定されると、その後、有効な メソッドが次に呼び出されるまでそのまま有効です。

指定された関係マスクは、プロセス関係マスクのサブセットである必要はありません。 プロセスアフィニティは必要に応じて更新されます。

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

パラメーター

_ProcessAffinityMask
同時実行ランタイムのワーカー スレッドを制限するアフィニティ マスク。 64 を超えるハードウェア スレッドを備えたシステムでは、同時実行ランタイムを現在のプロセッサ グループのサブセットに制限する場合にのみ、このメソッドを使用します。 一般に、64 を超えるハードウェア スレッドを備えたマシンでアフィニティを制限するには、グループ アフィニティの配列をパラメーターとして受け入れるメソッドのバージョンを使用する必要があります。

数える
パラメーター で指定された配列内の エントリの数。

_PGroupAffinity
エントリの配列。

解説

メソッドは、呼び出し時にResource Managerが存在する場合は invalid_operation 例外をスローし、指定されたアフィニティでリソースのセットが空の場合は invalid_argument 例外をスローします。

パラメーターとしてグループ アフィニティの配列を受け取るメソッドのバージョンは、バージョンが Windows 7 以上のオペレーティング システムでのみ使用してください。 それ以外の場合は、invalid_operation 例外が投げられます。

このメソッドが呼び出された後にプロセス アフィニティをプログラムで変更しても、Resource Managerは制限されているアフィニティを再評価しません。 そのため、プロセス アフィニティに対する変更はすべて、このメソッドを呼び出す前に行う必要があります。

入れ替える

2 つの オブジェクトの要素を交換します。

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

パラメーター

T
同時実行ベクターに格納されている要素のデータ型。

_Ax
同時実行ベクターのアロケーター型。

_A
その要素が同時実行ベクター の要素と交換される同時実行ベクター。

_B
入れ替える要素を提供する同時実行ベクター、またはその要素が同時実行ベクター の要素と交換されるベクター。

解説

テンプレート関数は、コンテナー クラス に特化したアルゴリズムであり、メンバー関数 を実行します。 concurrent_vector::swap()。 これらは、コンパイラによる関数テンプレートの部分的な順序付けのインスタンスです。 テンプレートと関数呼び出しの照合が一意にならないようにテンプレート関数がオーバーロードされた場合、コンパイラは、最も特化したバージョンのテンプレート関数を選択します。 テンプレート関数の一般的なバージョンであり、algorithm クラスにある は、代入によって機能し、処理が低速です。 各コンテナー内の特化バージョンのほうが、コンテナー クラスの内部表現で使用できるため大幅に高速になります。

このメソッドはコンカレンシー セーフではありません。 このメソッドを呼び出す際は、どちらの同時実行ベクターに対しても他のスレッドが演算を実行していないことを確認する必要があります。

例外からのタスク

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

パラメーター

_TaskType

_ExType

_例外

_TaskOptions

戻り値

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

パラメーター

T

_Param

_TaskOptions

戻り値

トレース_エージェント_登録_名前

指定された名前を、ETW トレースのメッセージ ブロックまたはエージェントに関連付けます。

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

パラメーター

T
オブジェクトの型。 これは通常、メッセージ ブロックまたはエージェントです。

_PObject
トレースで名前が付けられるメッセージ ブロックまたはエージェントへのポインター。

_名前
指定したオブジェクトの名前。

try_receive

try-receive の一般的な実装です。これにより、コンテキストで 1 つのソースに対してのみデータの検索を実行し、受け取った値をフィルター処理できます。 データの準備ができていない場合、メソッドは を返します。

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

パラメーター

T
ペイロードタイプ

_Src
データの要求先であるソースへのポインターまたは参照。

_価値
結果が配置される場所への参照。

_Filter_proc
メッセージを受け入れるかどうかを決定するフィルター関数。

戻り値

ペイロードが に配置されたかどうかを示す 値。

解説

詳細については、「メッセージ パッシング関数」を参照してください。

待ってください

指定した時間だけ現在のコンテキストを停止します。

void __cdecl wait(unsigned int _Milliseconds);

パラメーター

_ミリ秒
現在のコンテキストを一時停止するミリ秒数。 パラメーターが値 に設定されている場合、現在のコンテキストは続行する前に、実行可能な他のコンテキストに実行を譲る必要があります。

解説

このメソッドが同時実行ランタイムのスケジューラ コンテキストで呼び出された場合、スケジューラは基になるリソースで実行するために別のコンテキストを見つけます。 スケジューラは実際には協調的なので、指定されたミリ秒が経過した直後に、このコンテキストが再開することはありません。 スケジューラが他のタスクの実行で忙しく、それらのタスクがスケジューラにうまく協力しない場合、待機時間は無期限になる可能性があります。

when_all

引数として指定されたすべてのタスクが正常に完了したときに正常に完了するタスクを作成します。

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

パラメーター

_イテレータ
入力反復子の型。

_始める
結果のタスクに組み込まれる要素範囲内にある最初の要素の位置。

_終わり
結果のタスクに組み込まれる要素範囲外にある最初の要素の位置。

_TaskOptions
オブジェクトです。

戻り値

入力したすべてのタスクが正常に完了したときに正常に完了するタスク。 入力したタスクの種類が である場合、この関数の出力は になります。 入力したタスクの種類が である場合、出力のタスクも になります。

解説

は、その結果、 を生成する、非ブロッキング関数です。 task::wait とは異なり、UWP アプリのこの関数は ASTA (アプリケーション STA) スレッドで安全に呼び出することができます。

タスクのいずれかがキャンセルされた場合、または例外がスローされた場合、返されるタスクは早期に完了し、キャンセルされた状態になります。また、例外が発生するとすれば、そのタスクに対して task::get または を呼び出した場合に、その例外がスローされます。

詳しくは、タスクの並列処理に関するページを参照してください。

when_any

引数として指定されたいずれかのタスクが正常に完了したときに正常に完了するタスクを作成します。

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

パラメーター

_イテレータ
入力反復子の型。

_始める
結果のタスクに組み込まれる要素範囲内にある最初の要素の位置。

_終わり
結果のタスクに組み込まれる要素範囲外にある最初の要素の位置。

_TaskOptions
_CancellationToken
返されたタスクの取り消しを制御するキャンセル トークン。 キャンセル トークンを指定しない場合、結果のタスクは、完了の原因となったタスクのキャンセル トークンを受け取ります。

戻り値

入力したタスクのいずれかが正常に完了したときに正常に完了するタスク。 入力したタスクの種類が である場合、この関数の出力は になります。ここでは、pair の最初の要素は完了したタスクの結果であり、2 番目の要素は完了したタスクのインデックスです。 入力したタスクの種類が である場合、出力は になります。この場合、結果は完了したタスクのインデックスです。

解説

は、その結果、 を生成する、非ブロッキング関数です。 task::wait とは異なり、UWP アプリのこの関数は ASTA (アプリケーション STA) スレッドで安全に呼び出することができます。

詳しくは、タスクの並列処理に関するページを参照してください。

関連項目

コンカレンシー名前空間