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

Alloc
asend
cancel_current_task
clear
create_async
create_task
CreateResourceManager
DisableTracing
EnableTracing
Free
get_ambient_scheduler
GetExecutionContextId
GetOSVersion
GetProcessorCount
GetProcessorNodeCount

GetSchedulerId
internal_assign_iterators
interruption_point
is_current_task_group_canceling
make_choice
make_greedy_join
make_join
make_task
parallel_buffered_sort
parallel_for_each
parallel_for
parallel_invoke
parallel_radixsort
parallel_reduce
parallel_sort

parallel_transform
receive
run_with_cancellation_token
send
set_ambient_scheduler
set_task_execution_resources
swap
task_from_exception
task_from_result
Trace_agents_register_name
try_receive
wait
when_all
when_any

Alloc

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

void* __cdecl Alloc(size_t _NumBytes);

パラメーター

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

戻り値

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

解説

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

asend

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

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
データの送信先となるターゲットへのポインターまたは参照。

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

戻り値

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

解説

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

cancel_current_task

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

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

inline __declspec(noreturn) void __cdecl cancel_current_task();

clear

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

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

パラメーター

T

_Ax

create_async

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

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

パラメーター

_Function
Type。

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

戻り値

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

解説

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

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

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

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

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

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

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

CreateResourceManager

コンカレンシー ランタイムのリソース マネージャーのシングルトン インスタンスを表すインターフェイスを返します。 リソース マネージャーは、相互の連携を必要とするスケジューラにリソースを割り当てます。

IResourceManager* __cdecl CreateResourceManager();

戻り値

IResourceManager インターフェイスです。

解説

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

オペレーティング システムが同時実行ランタイムによってサポートされていない場合は、unsupported_os がスローされます。

create_task

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

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
Type。

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

_TaskOptions
タスクのオプションです。

_Task
作成するタスクです。

戻り値

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

解説

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

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

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

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

DisableTracing

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

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

戻り値

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

EnableTracing

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

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

戻り値

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

制限なし

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

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

パラメーター

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

解説

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

get_ambient_scheduler

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

戻り値

GetExecutionContextId

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

unsigned int __cdecl GetExecutionContextId();

戻り値

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

解説

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

GetOSVersion

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

IResourceManager::OSVersion __cdecl GetOSVersion();

戻り値

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

解説

オペレーティング システムが同時実行ランタイムによってサポートされていない場合は、unsupported_os がスローされます。

GetProcessorCount

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

unsigned int __cdecl GetProcessorCount();

戻り値

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

解説

オペレーティング システムが同時実行ランタイムによってサポートされていない場合は、unsupported_os がスローされます。

GetProcessorNodeCount

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

unsigned int __cdecl GetProcessorNodeCount();

戻り値

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

解説

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

オペレーティング システムが同時実行ランタイムによってサポートされていない場合は、unsupported_os がスローされます。

GetSchedulerId

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

unsigned int __cdecl GetSchedulerId();

戻り値

スケジューラの一意識別子。

解説

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

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

first

last

interruption_point

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

inline void interruption_point();

解説

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

is_current_task_group_canceling

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

bool __cdecl is_current_task_group_canceling();

戻り値

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

解説

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

make_choice

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

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
その内部で Scheduler メッセージング ブロックの反映タスクがスケジュールされる choice オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_Items
その他のソース。

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

戻り値

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

make_greedy_join

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

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
その内部で Scheduler メッセージング ブロックの反映タスクがスケジュールされる multitype_join オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_Items
その他のソース。

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

戻り値

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

make_join

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

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
その内部で Scheduler メッセージング ブロックの反映タスクがスケジュールされる multitype_join オブジェクト。

_Item1
1 番目のソース。

_Item2
2 番目のソース。

_Items
その他のソース。

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

戻り値

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

make_task

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

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

パラメーター

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

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

戻り値

task_handle オブジェクト。

解説

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

parallel_buffered_sort

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

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
入力範囲の反復子の型。

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

_Function
二項比較子の型。

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

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

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

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

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

解説

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

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

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

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

parallel_for

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
反復処理に使用されるインデックスの型。

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

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

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

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

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

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

_Part
パーティショナー オブジェクトへの参照。 引数には、constauto_partitioner&、conststatic_partitioner&、constsimple_partitioner&、または affinity_partitioner& のいずれかを指定できます。affinity_partitioner オブジェクトを使用する場合、参照は非定数の左辺値参照にする必要があります。これにより、アルゴリズムで状態を格納して将来のループで再利用できるようになります。

解説

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

parallel_for_each

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

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

パラメーター

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

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

_Partitioner
first
並列反復処理に含める最初の要素の位置を示す反復子。

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

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

_Part
パーティショナー オブジェクトへの参照。 引数には、constauto_partitioner&、conststatic_partitioner&、constsimple_partitioner&、または affinity_partitioner& のいずれかを指定できます。affinity_partitioner オブジェクトを使用する場合、参照は非定数の左辺値参照にする必要があります。これにより、アルゴリズムで状態を格納して将来のループで再利用できるようになります。

解説

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

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

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

parallel_invoke

パラメーターとして渡された関数オブジェクトを並列実行し、実行が完了するまでブロックします。 各関数オブジェクトは、ラムダ式、関数へのポインター、またはシグネチャ 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);

パラメーター

_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_invoke への呼び出しの外部に反映します。

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

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
入力範囲の反復子の型。

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

_Function
投射関数の型。

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

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

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

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

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

解説

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

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

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

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

parallel_reduce

連続する部分的な合計を計算することで、指定された範囲のすべての要素の合計を計算します。または、指定された二項演算を使用して取得した、合計以外の連続する部分的な結果を並列で計算します。 parallel_reduce は std::accumulate と意味が同じです。ただし、結合のための二項演算と、初期値ではなく 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 _Sym_fun(_Reduce_type, _Reduce_type) を備えた関数型である必要があります。ここで、_Reduce_type は、ID 型、および減少の結果の型と同じです。 3 番目のオーバーロードの場合、これは _Range_reduce_fun の出力型と一致している必要があります。

_Reduce_type
入力が帰着する型。入力要素の型とは異なる場合があります。 戻り値と ID 値は、この型になります。

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

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

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

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

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

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

戻り値

減少の結果。

解説

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

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

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

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

parallel_sort

指定された範囲の要素を、降順以外の順序、または二項述語で指定された順序の基準に従って並列に配置します。 この関数は、比較ベースで不安定なインプレース並べ替えという点で std::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
入力範囲の反復子の型。

_Function
二項比較ファンクターの型。

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

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

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

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

解説

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

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

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

parallel_transform

指定された関数オブジェクトをソース範囲内の各要素、または 2 つのソース範囲内の要素のペアに適用し、関数オブジェクトの戻り値をコピー先の範囲に並列でコピーします。 この関数は、意味的には 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);

パラメーター

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

_Output_iterator
出力反復子の型。

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

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

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

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

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

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

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

_Part
パーティショナー オブジェクトへの参照。 引数には、constauto_partitioner&、conststatic_partitioner&、constsimple_partitioner&、または affinity_partitioner& のいずれかを指定できます。affinity_partitioner オブジェクトを使用する場合、参照は非定数の左辺値参照にする必要があります。これにより、アルゴリズムで状態を格納して将来のループで再利用できるようになります。

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

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

戻り値

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

解説

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

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

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

引数 _Binary_op を受け取るオーバーロードは、最初の入力範囲の 1 つの要素と 2 番目の入力範囲の 1 つの要素に二項ファンクターを適用することで、2 つの入力範囲を出力範囲に変換します。 _Binary_op は、シグネチャ operator()(T, U) を備えた関数呼び出し演算子をサポートする必要があります。ここで、T、U は 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
データの要求先であるソースへのポインターまたは参照。

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

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

戻り値

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

解説

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

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

run_with_cancellation_token

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

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

パラメーター

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

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

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

解説

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

[Send]

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

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
データの送信先となるターゲットへのポインターまたは参照。

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

戻り値

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

解説

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

set_ambient_scheduler

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

パラメーター

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

set_task_execution_resources

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

このメソッドの呼び出しは、リソース マネージャーの作成前、または 2 つのリソース マネージャーの有効期間の間のみ有効です。 これは、呼び出し時にリソース マネージャーが存在しない限り複数回呼び出すことができます。 関係の制限が設定されたら、次の有効な set_task_execution_resources メソッド呼び出しまで保持されます。

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

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

パラメーター

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

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

_PGroupAffinity
GROUP_AFFINITY エントリの配列。

解説

このメソッドは、呼び出し時にリソース マネージャーが存在する場合は invalid_operation 例外をスローし、指定したアフィニティによって空のリソース セットが生成された場合は invalid_argument 例外をスローします。

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

このメソッドが呼び出された後にプログラムでプロセス アフィニティを変更すると、制限されているアフィニティをリソース マネージャーで再評価できなくなります。 そのため、プロセス アフィニティに対する変更はすべて、このメソッドを呼び出す前に行う必要があります。

スワップ

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

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

パラメーター

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

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

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

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

解説

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

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

task_from_exception

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

パラメーター

_TaskType

_ExType

_Exception

_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

戻り値

Trace_agents_register_name

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

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

パラメーター

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

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

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

try_receive

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

パラメーター

T
ペイロードの型

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

_value
結果が配置される場所への参照。

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

戻り値

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

解説

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

wait

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

void __cdecl wait(unsigned int _Milliseconds);

パラメーター

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

解説

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

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

パラメーター

_Iterator
入力反復子の型。

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

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

_TaskOptions
task_options オブジェクトです。

戻り値

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

解説

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

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

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

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

パラメーター

_Iterator
入力反復子の型。

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

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

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

戻り値

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

解説

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

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

関連項目

コンカレンシー名前空間