concurrency 네임스페이스 함수

아티클
10/12/2023

Alloc

동시성 런타임 캐싱 하위 할당기에서 지정된 크기의 메모리 블록을 할당합니다.

void* __cdecl Alloc(size_t _NumBytes);

매개 변수

_NumBytes
할당할 메모리의 바이트 수입니다.

Return Value

새로 할당된 메모리에 대한 포인터입니다.

설명

애플리케이션에서 캐싱 하위 할당자를 사용하면 어떤 시나리오가 도움이 될 수 있는지에 대한 자세한 내용은 작업 스케줄러를 참조하세요.

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
데이터가 전송되는 대상에 대한 포인터 또는 참조입니다.

_데이터
보낼 데이터에 대한 참조입니다.

Return Value

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

매개 변수

_도끼

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

매개 변수

_함수
유형.

_Func
Windows 런타임 비동기 구문을 만들 람다 또는 함수 개체입니다.

Return Value

IAsyncAction^, IAsyncActionWithProgress TProgress<>^, IAsyncOperation TResult>^또는 IAsyncOperationWithProgress<<TResult, TProgress>^로 표현되는 비동기 구문입니다. 반환된 인터페이스는 함수에 전달되는 람다의 시그니처에 종속됩니다.

설명

람다의 반환 형식은 구문이 동작 또는 작업인지 여부를 결정합니다.

void를 반환하는 람다는 작업을 생성합니다. TResult 형식의 결과를 반환하는 람다는 TResult 작업을 생성합니다.

람다는 비동기 작업을 자체 내에 캡슐화하거나 비동기 작업을 나타내는 연속 작업 체인인 task<TResult>를 반환할 수도 있습니다. 이 경우 작업은 비동기적으로 실행되므로 람다 자체가 인라인으로 실행되며, 람다의 반환 형식은 래핑이 해제되어 create_async에서 반환된 비동기 구문을 생성합니다. 이는 작업<무효> 를 반환하는 람다가 작업을 생성하고 TResult 작업을<반환하는 람다가 TResult> 작업을 생성하게 됨을 의미합니다.

람다는 0개, 하나 또는 두 개의 인수를 사용할 수 있습니다. 해당 순서로 함께 사용되는 경우 올바른 인수는 progress_reporter<TProgress> 및 cancellation_token입니다. 인수가 없는 람다를 사용하면 진행률을 보고할 수 없는 비동기 구문이 생성됩니다. progress_reporter TProgress>를 사용하는 람다는 progress_reporter<개체의 메서드가 호출될 create_async 때마다 report TProgress 형식의 진행률을 보고하는 비동기 구문을 반환합니다. cancellation_token을 사용하는 람다는 해당 토큰을 사용하여 취소 여부를 확인하거나 이 토큰이 생성하는 작업에 전달되어 비동기 구문의 취소가 이러한 작업의 취소를 발생시키도록 할 수 있습니다.

람다 또는 함수 개체의 본문이 TResult> 작업이<아닌 결과를 반환하는 경우 런타임에서 암시적으로 만드는 작업의 컨텍스트에서 프로세스 MTA 내에서 lamdba가 비동기적으로 실행됩니다. IAsyncInfo::Cancel 메서드는 암시적 작업의 취소를 발생시킵니다.

람다 본문이 작업을 반환하는 경우 람다는 인라인 실행됩니다. 그리고 람다가 cancellation_token 형식의 인수를 갖도록 선언함으로써 작업을 만들 때 해당 토큰을 전달하여 람다 내부에서 만든 모든 작업의 취소를 트리거할 수 있습니다. 생성된 비동기 작업 또는 동작에서 register_callback을 호출할 때 런타임에서 콜백을 호출하도록 토큰에 IAsyncInfo::Cancel 메서드를 사용할 수도 있습니다.

이 함수는 Windows 런타임 앱에서만 사용할 수 있습니다.

CreateResourceManager

동시성 런타임 리소스 관리자의 singleton 인스턴스를 나타내는 인터페이스를 반환합니다. 리소스 관리자는 서로 협력하려는 스케줄러에 리소스를 할당해야 합니다.

IResourceManager* __cdecl CreateResourceManager();

Return Value

IResourceManager 인터페이스입니다.

설명

이 메서드에 대한 여러 후속 호출은 Resource Manager의 동일한 인스턴스를 반환합니다. 메서드에 대한 각 호출은 Resource Manager에 대한 참조 수를 증가시키고 스케줄러가 Resource Manager와 통신을 완료할 때 IResourceManager::Release 메서드에 대한 호출과 일치해야 합니다.

운영 체제가 동시성 런타임에서 지원되지 않는 경우 unsupported_os throw됩니다.

create_task

PPL 작업 개체를 만듭니다. 작업 생성자를 사용하는 곳이면 어디에나 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
유형.

_Param
작업이 생성되는 매개 변수입니다. UWP 앱에서 작업을 사용하는 경우 람다 또는 함수 개체, task_completion_event 개체, 다른 task 개체 또는 Windows::Foundation::IAsyncInfo 인터페이스일 수 있습니다.

_TaskOptions
작업 옵션입니다.

_작업
만들 작업입니다.

Return Value

에서 유추_Param되는 형식T의 새 작업입니다.

설명

첫 번째 오버로드는 단일 매개 변수를 사용하는 작업 생성자처럼 동작합니다.

두 번째 오버로드는 새로 만든 작업과 제공된 취소 토큰을 연결합니다. 이 오버로드를 사용하는 경우 다른 task 개체를 첫 번째 매개 변수로 전달할 수 없습니다.

반환된 작업의 형식은 첫 번째 매개 변수에서 함수로 유추됩니다. 형식 task<T>또는 형식을 task<T>반환하는 functor 또는 functor인 경우 _Param 생성된 작업의 형식은 .입니다task<T>.Ttask_completion_event<T>

UWP 앱에서 Windows::Foundation::IAsyncOperation<T>^ 또는 Windows::Foundation::IAsyncOperationWithProgress<T,P>^또는 이러한 형식 중 하나를 반환하는 functor 형식인 경우 _Param 생성된 작업은 형식task<T>입니다. Windows::Foundation::IAsyncAction^ 또는 Windows::Foundation::IAsyncActionWithProgress<P>^형식이거나 이러한 형식 중 하나를 반환하는 functor인 경우 _Param 생성된 작업에는 형식task<void>이 있습니다.

DisableTracing

동시성 런타임에서 추적을 사용하지 않도록 설정합니다. ETW 추적이 기본적으로 등록되지 않으므로 이 함수는 사용되지 않습니다.

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

Return Value

추적을 올바르게 사용하지 않도록 설정한 S_OK 경우 반환됩니다. 추적이 이전에 시작되지 않은 경우 E_NOT_STARTED가 반환됩니다.

EnableTracing

동시성 런타임에서 추적을 사용하도록 설정합니다. 이제 ETW 추적이 기본적으로 설정되므로 이 함수는 사용되지 않습니다.

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

Return Value

추적이 올바르게 시작된 경우 반환되고, S_OKE_NOT_STARTED 그렇지 않으면 반환됩니다.

무료

Alloc 메서드에 의해 동시성 런타임 캐싱 하위 할당자에 이전에 할당된 메모리 블록을 해제합니다.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

매개 변수

_PAllocation
해제할 메서드에 의해 Alloc 이전에 할당된 메모리에 대한 포인터입니다. 매개 변수가 값NULL으로 설정된 경우 이 메서드는 매개 변수 _PAllocation 를 무시하고 즉시 반환합니다.

설명

애플리케이션에서 캐싱 하위 할당자를 사용하면 어떤 시나리오가 도움이 될 수 있는지에 대한 자세한 내용은 작업 스케줄러를 참조하세요.

get_ambient_scheduler

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

Return Value

GetExecutionContextId

IExecutionContext 인터페이스를 구현하는 실행 컨텍스트에 할당할 수 있는 고유 식별자를 반환합니다.

unsigned int __cdecl GetExecutionContextId();

Return Value

실행 컨텍스트에 대한 고유 식별자입니다.

설명

Resource Manager에서 제공하는 메서드 중 하나로 인터페이스를 매개 변수로 전달 IExecutionContext 하기 전에 이 메서드를 사용하여 실행 컨텍스트에 대한 식별자를 가져옵니다.

GetOSVersion

운영 체제 버전을 반환합니다.

IResourceManager::OSVersion __cdecl GetOSVersion();

Return Value

운영 체제를 나타내는 열거형 값입니다.

설명

운영 체제가 동시성 런타임에서 지원되지 않는 경우 unsupported_os throw됩니다.

GetProcessorCount

기본 시스템의 하드웨어 스레드 수를 반환합니다.

unsigned int __cdecl GetProcessorCount();

Return Value

하드웨어 스레드 수입니다.

설명

운영 체제가 동시성 런타임에서 지원되지 않는 경우 unsupported_os throw됩니다.

GetProcessorNodeCount

기본 시스템의 NUMA 노드 또는 프로세서 패키지 수를 반환합니다.

unsigned int __cdecl GetProcessorNodeCount();

Return Value

NUMA 노드 또는 프로세서 패키지의 수입니다.

설명

시스템에 프로세서 패키지보다 더 많은 NUMA 노드가 포함된 경우 NUMA 노드 수가 반환되고, 그렇지 않으면 프로세서 패키지 수가 반환됩니다.

운영 체제가 동시성 런타임에서 지원되지 않는 경우 unsupported_os throw됩니다.

GetSchedulerId

IScheduler 인터페이스를 구현하는 스케줄러에 할당할 수 있는 고유 식별자를 반환합니다.

unsigned int __cdecl GetSchedulerId();

Return Value

스케줄러의 고유 식별자입니다.

설명

Resource Manager에서 제공하는 메서드 중 하나로 인터페이스를 매개 변수로 전달 IScheduler 하기 전에 이 메서드를 사용하여 스케줄러에 대한 식별자를 가져옵니다.

internal_assign_iterators

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

매개 변수

_도끼

first

last

interruption_point

취소를 위한 중단 지점을 만듭니다. 이 함수가 호출된 컨텍스트에서 취소가 진행 중이면 현재 실행 중인 병렬 작업의 실행을 중단하는 내부 예외가 발생합니다. 취소가 진행되고 있지 않으면 함수에서 아무 작업도 하지 않습니다.

inline void interruption_point();

설명

interruption_point() 함수에 의해 throw된 내부 취소 예외를 catch하면 안 됩니다. 예외는 런타임에서 catch되어 처리되며, 예외를 catch하면 프로그램이 비정상적으로 동작할 수 있습니다.

is_current_task_group_canceling

현재 컨텍스트에서 현재 인라인으로 실행 중인 작업 그룹이 활성 취소 중이거나 곧 취소되는지 여부를 나타내는 표시를 반환합니다. 현재 컨텍스트에서 현재 인라인으로 실행 중인 작업 그룹이 없는 경우 false가 반환됩니다.

bool __cdecl is_current_task_group_canceling();

Return Value

true 현재 실행 중인 작업 그룹이 취소 false 되면 그렇지 않습니다.

설명

자세한 내용은 취소를 참조하세요.

make_choice

선택적 choice 또는 Scheduler과 두 개 이상의 입력 소스로 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
첫 번째 원본의 메시지 블록 형식입니다.

T2
두 번째 원본의 메시지 블록 형식입니다.

_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 choice 개체입니다.

_Item1
첫 번째 소스입니다.

_Item2
두 번째 소스입니다.

_항목
추가적인 소스입니다.

_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 choice 개체입니다. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.

Return Value

두 개 이상의 입력 소스가 있는 choice 메시지 블록입니다.

make_greedy_join

선택적 greedy multitype_join 또는 Scheduler과 두 개 이상의 입력 소스로 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
첫 번째 원본의 메시지 블록 형식입니다.

T2
두 번째 원본의 메시지 블록 형식입니다.

_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.

_Item1
첫 번째 소스입니다.

_Item2
두 번째 소스입니다.

_항목
추가적인 소스입니다.

_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.

Return Value

두 개 이상의 입력 소스가 있는 greedy multitype_join 메시지 블록입니다.

make_join

선택적 non_greedy multitype_join 또는 Scheduler과 두 개 이상의 입력 소스로 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
첫 번째 원본의 메시지 블록 형식입니다.

T2
두 번째 원본의 메시지 블록 형식입니다.

_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.

_Item1
첫 번째 소스입니다.

_Item2
두 번째 소스입니다.

_항목
추가적인 소스입니다.

_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.

Return Value

두 개 이상의 입력 소스가 있는 non_greedy multitype_join 메시지 블록입니다.

make_task

task_handle 개체를 만들기 위한 팩터리 메서드입니다.

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

매개 변수

_함수
개체가 나타내는 작업을 실행하기 위해 호출될 함수 개체의 task_handle 형식입니다.

_Func
개체가 나타내는 작업을 실행하기 위해 호출될 task_handle 함수입니다. 람다 펀터, 함수에 대한 포인터 또는 시그니처 void operator()()가 있는 함수 호출 연산자의 버전을 지원하는 개체일 수 있습니다.

Return Value

task_handle 개체입니다.

설명

이 함수는 람다 식을 사용하여 개체를 task_handle 만들어야 하는 경우에 유용합니다. 람다 펀터의 실제 형식을 모르고 개체를 만들 수 있기 때문입니다.

parallel_buffered_sort

지정된 범위의 요소를 내림차순이 아닌 순서로 정렬하거나 이진 조건자에서 지정한 순서 기준에 따라 병렬로 정렬합니다. 이 함수는 O(n) 추가 공간이 필요하고 정렬되는 요소에 대한 기본 초기화를 요구한다는 점을 제외하고, 비교 기반의 불안정한 내부 정렬이라는 점에서 std::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++ 표준 라이브러리 호환 메모리 할당자의 형식입니다.

_함수
이진 비교자의 형식입니다.

_시작
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.

_끝
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.

_Alloc
C++ 표준 라이브러리 호환 메모리 할당자의 인스턴스입니다.

_Func
순서에 따라 연속적인 요소에 대해 충족될 비교 조건을 정의하는 사용자 정의 조건자 함수 개체입니다. 이진 조건자는 두 개의 인수를 사용하여 조건이 충족되면 true를 반환하고, 충족되지 않으면 false를 반환합니다. 이 비교 함수는 시퀀스의 요소 쌍에 대해 엄밀히 약한 순서를 적용해야 합니다.

_Chunk_size
병렬 실행을 위해 두 개로 분할될 청크의 최소 크기입니다.

설명

모든 오버로드에는 정렬할 요소 수와 T 요소 형식인 추가 공간이 n 필요합니다n * sizeof(T). 대부분의 경우 parallel_buffered_sort parallel_sort 비해 성능이 향상되며, 사용 가능한 메모리가 있는 경우 parallel_sort 통해 사용해야 합니다.

이진 비교자를 std::less 제공하지 않으면 기본값으로 사용되므로 요소 형식이 연산 operator<()자를 제공해야 합니다.

할당자 형식 또는 인스턴스를 제공하지 않으면 C++ 표준 라이브러리 메모리 할당자를 std::allocator<T> 사용하여 버퍼를 할당합니다.

알고리즘은 입력 범위를 두 개의 청크로 나누고 이어서 각 청크를 병렬로 실행할 두 개의 하위 청크로 나눕니다. 선택적 인수 _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
반복에 사용되는 인덱스의 형식입니다.

_함수
각 반복에서 실행할 함수의 형식입니다.

_Partitioner
제공된 범위를 분할하는 데 사용되는 파티셔너의 형식입니다.

first
반복에 포함할 첫 번째 인덱스입니다.

last
반복에 포함할 마지막 인덱스 하나를 지난 인덱스입니다.

_단계
를 반복할 때 단계별로 firstlast실행할 값입니다. 단계는 양수여야 합니다. 단계가 1보다 작은 경우 invalid_argument throw됩니다.

_Func
각 반복에서 실행할 함수입니다. 람다 식, 함수 포인터 또는 시그니처 void operator()(_Index_type)가 있는 함수 호출 연산자의 버전을 지원하는 개체일 수 있습니다.

_부분
partitioner 개체에 대한 참조입니다. 인수는 auto_partitioner&, static_partitioner,constconst simple_partitioner&& 또는 affinity_partitioner& 중 하나const일 수 affinity_partitioner 개체를 사용하는 경우 알고리즘이 향후 루프를 다시 사용하기 위해 상태를 저장할 수 있도록 참조가 비 const l-value 참조여야 합니다.

설명

자세한 내용은 병렬 알고리즘을 참조 하세요.

parallel_for_each

parallel_for_each는 범위 내의 각 요소에 지정된 함수를 병렬로 적용합니다. 요소에 대한 반복이 병렬로 수행되고 반복 순서가 지정되지 않는다는 점을 제외하고 std 네임스페이스의 for_each 함수와 의미 체계가 같습니다. _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);

매개 변수

_반복기
컨테이너를 반복하는 데 사용되는 반복기의 형식입니다.

_함수
범위 내의 각 요소에 적용할 함수의 형식입니다.

_Partitioner
first
병렬 반복에 포함할 첫 번째 요소의 위치를 다루는 반복기입니다.

last
병렬 반복에 포함할 마지막 요소 중 하나 다음 위치의 주소를 지정하는 반복기입니다.

_Func
범위의 각 요소에 적용되는 사용자 정의 함수 개체입니다.

설명

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
병렬로 실행할 두 번째 함수 개체의 형식입니다.

_Function3
병렬로 실행할 세 번째 함수 개체의 형식입니다.

_Function4
병렬로 실행할 네 번째 함수 개체의 형식입니다.

_Function5
병렬로 실행할 다섯 번째 함수 개체의 형식입니다.

_Function6
병렬로 실행할 여섯 번째 함수 개체의 형식입니다.

_Function7
병렬로 실행할 일곱 번째 함수 개체의 형식입니다.

_Function8
병렬로 실행할 여덟 번째 함수 개체의 형식입니다.

_Function9
병렬로 실행할 아홉 번째 함수 개체의 형식입니다.

_Function10
병렬로 실행할 열 번째 함수 개체의 형식입니다.

_Func1
병렬로 실행할 첫 번째 함수 개체입니다.

_Func2
병렬로 실행할 두 번째 함수 개체입니다.

_Func3
병렬로 실행할 세 번째 함수 개체입니다.

_Func4
병렬로 실행할 네 번째 함수 개체입니다.

_Func5
병렬로 실행할 다섯 번째 함수 개체입니다.

_Func6
병렬로 실행할 여섯 번째 함수 개체입니다.

_Func7
병렬로 실행할 일곱 번째 함수 개체입니다.

_Func8
병렬로 실행할 여덟 번째 함수 개체입니다.

_Func9
병렬로 실행할 아홉 번째 함수 개체입니다.

_Func10
병렬로 실행할 열 번째 함수 개체입니다.

설명

매개 변수로 제공된 함수 개체 중 하나 이상이 호출 컨텍스트에서 인라인으로 실행될 수 있습니다.

이 함수에 매개 변수로 전달된 함수 개체 중 하나 이상이 예외를 throw하는 경우 런타임은 이러한 예외 중 하나를 선택하여 호출에서 전파합니다 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
입력 범위의 반복기 형식입니다.

_할당자
C++ 표준 라이브러리 호환 메모리 할당자의 형식입니다.

_함수
프로젝션 함수의 형식입니다.

_시작
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.

_끝
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.

_Alloc
C++ 표준 라이브러리 호환 메모리 할당자의 인스턴스입니다.

_Proj_func
요소를 정수 값으로 변환하는 사용자 정의 프로젝션 함수 개체입니다.

_Chunk_size
병렬 실행을 위해 두 개로 분할될 청크의 최소 크기입니다.

설명

모든 오버로드에는 정렬할 요소 수와 T 요소 형식인 추가 공간이 n 필요합니다n * sizeof(T). 요소 형식 I 이고 부호 없는 정수와 유사한 형식인 요소가 지정된 경우 시그니처 I _Proj_func(T) 가 있는 T 단항 프로젝션 펀터가 키를 반환해야 합니다.

프로젝션 함수를 제공하지 않으면 요소를 단순히 반환하는 기본 프로젝션 함수가 정수 형식에 사용됩니다. 프로젝션 함수가 없는 경우 요소가 정수 형식이 아닌 경우 함수가 컴파일되지 않습니다.

할당자 형식 또는 인스턴스를 제공하지 않으면 C++ 표준 라이브러리 메모리 할당자를 std::allocator<T> 사용하여 버퍼를 할당합니다.

parallel_reduce

연속적 부분 합계를 계산하여 지정된 범위 내 모든 요소의 합계를 계산하거나, 합계 대신 지정된 이항 연산을 사용하여 유사하게 구한 연속적 부분 결과의 결과를 병렬로 계산합니다. parallel_reduce는 이항 연산이 결합형이어야 하고 초기 값 대신 ID 값을 요구한다는 점을 제외하고 std::accumulate와 의미 체계가 비슷합니다.

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 형식 및 감소의 결과 형식과 동일합니다. 세 번째 오버로드의 경우 출력 형식 _Range_reduce_fun과 일치해야 합니다.

_Reduce_type
입력이 감소할 형식이며 입력 요소 형식과 다를 수 있습니다. 반환 값 및 ID 값에는 이 형식이 있습니다.

_Range_reduce_fun
범위 감소 함수의 형식입니다. 서명이 있는 _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type)함수 형식이어야 합니다. _Reduce_type ID 형식 및 감소의 결과 형식과 동일합니다.

_시작
축소할 범위의 첫 번째 요소에 주소를 지정하는 입력 반복기입니다.

_끝
축소할 범위의 마지막 요소를 벗어난 한 위치인 요소의 주소를 지정하는 입력 반복기입니다.

_Id
ID 값 _Identity 은 감소의 결과 형식과 동일한 형식이며 첫 번째 및 두 번째 오버로드에 대한 반복기의 형식이기도 value_type 합니다. 세 번째 오버로드의 경우 ID 값은 감소의 결과 형식과 동일한 형식이어야 하지만 반복기와 다를 value_type 수 있습니다. 범위 감소 연산_Range_fun자가 형식의 단일 요소 범위에 적용되고 ID 값이 형식에서 value_type ID 형식 value_type 으로 값의 형식 캐스트처럼 동작하도록 적절한 값이 있어야 합니다.

_Sym_fun
감소의 두 번째에 사용될 대칭 함수입니다. 자세한 내용은 비고를 참조하세요.

_Range_fun
감소의 첫 번째 단계에서 사용할 함수입니다. 자세한 내용은 비고를 참조하세요.

Return Value

감소의 결과입니다.

설명

병렬 감소를 수행하기 위해 함수는 기본 스케줄러에서 사용할 수 있는 작업자 수에 따라 범위를 청크로 나눕니다. 감소는 두 단계로 이루어지고, 첫 번째 단계는 각 청크 내에서 감소를 수행하고, 두 번째 단계는 각 청크의 부분 결과 사이의 감소를 수행합니다.

첫 번째 오버로드를 사용하려면 반복기의 value_typeTID 값 형식 및 감소 결과 형식과 동일해야 합니다. 요소 형식 T는 각 청크의 요소를 줄이기 위해 연산 T T::operator + (T) 자를 제공해야 합니다. 두 번째 단계에서도 동일한 연산자가 사용됩니다.

또한 두 번째 오버로드를 사용하려면 반복기가 value_type ID 값 형식과 동일해야 하며 감소 결과 형식도 필요합니다. 제공된 이진 연산 _Sym_fun 자는 두 감소 단계에서 모두 사용되며 ID 값은 첫 번째 단계의 초기 값으로 사용됩니다.

세 번째 오버로드의 경우 ID 값 형식은 감소 결과 형식과 동일해야 하지만 반복기는 value_type 둘 다와 다를 수 있습니다. 범위 감소 함수 _Range_fun 는 ID 값을 초기 값으로 사용하는 첫 번째 단계에서 사용되며 이진 함수 _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
입력 범위의 반복기 형식입니다.

_함수
이진 비교 구조 함수의 형식입니다.

_시작
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.

_끝
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.

_Chunk_size
병렬 실행을 위해 두 으로 분할되는 청크의 최소 크기입니다.

설명

첫 번째 오버로드는 이진 비교자를 std::less사용합니다.

두 번째 오버로드는 bool _Func(T, T) 시그니처를 포함하는 제공된 이진 비교 연산자를 사용합니다. 여기서 T는 입력 범위 요소의 형식입니다.

parallel_transform

두 소스 범위에서 요소 쌍에 또는 소스 범위에 있는 각 요소에 지정된 함수 개체를 적용하고 대상 범위에 함수 개체의 반환 값을 병렬로 복사합니다. 이 함수는 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
두 번째 입력 반복기의 형식입니다.

_Binary_operator
두 소스 범위의 요소에서 쌍 단위로 실행될 이진 구조 함수의 형식입니다.

_Partitioner
first1
작업을 수행할 첫 번째 소스 범위 또는 유일한 소스 범위의 첫 번째 요소의 위치를 주소 지정하는 입력 반복기입니다.

last1
작업을 수행할 첫 번째 소스 범위 또는 유일한 소스 범위에서 최종 요소의 하나 다음 위치를 주소 지정하는 입력 반복기입니다.

_결과
대상 범위의 첫 번째 요소의 위치를 주소 지정하는 출력 반복기입니다.

_Unary_op
소스 범위의 각 요소에 적용되는 사용자 정의 단항 함수 개체입니다.

first2
작업을 수행할 두 번째 소스 범위에서 첫 번째 요소의 위치를 주소 지정하는 입력 반복기입니다.

_Binary_op
두 소스 범위에 쌍 단위 정방향으로 적용되는 사용자 정의 이진 함수 개체입니다.

Return Value

함수 개체에 의해 변형된 출력 요소를 받는 대상 범위에서 최종 요소의 하나 다음 위치를 주소 지정하는 출력 반복기입니다.

설명

auto_partitioner 명시적 파티셔너 인수 없이 오버로드에 사용됩니다.

임의 액세스를 지원하지 않는 반복기의 경우 auto_partitioner만 지원됩니다.

_Unary_op 인수를 사용하는 오버로드는 입력 범위의 각 요소에 단항 구조 함수를 적용하여 입력 범위를 출력 범위로 변환합니다. _Unary_op는 operator()(T) 시그니처를 포함하는 함수 호출 연산자를 지원해야 합니다. 여기서 T는 반복되는 범위의 값 형식입니다.

_Binary_op 인수를 사용하는 오버로드는 첫 번째 입력 범위의 한 요소와 두 번째 입력 범위의 한 요소에 이진 구조 함수를 적용하여 두 개의 입력 범위를 출력 범위로 변환합니다. _Binary_op는 operator()(T, U) 시그니처를 포함하는 함수 호출 연산자를 지원해야 합니다. 여기서 T, U는 두 입력 반복기의 값 형식입니다.

자세한 내용은 병렬 알고리즘을 참조 하세요.

수신

컨텍스트에서 정확히 한 소스의 데이터를 대기하고 허용되는 값을 필터링할 수 있게 하는 일반 receive 구현입니다.

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
메시지를 수락해야 하는지 여부를 결정하는 필터 함수입니다.

Return Value

페이로드 형식의 원본 값입니다.

설명

매개 변수 _Timeout 에 상수가 COOPERATIVE_TIMEOUT_INFINITE아닌 값이 있는 경우 메시지를 받기 전에 지정된 시간이 만료되면 operation_timed_out 예외가 throw됩니다. 길이 제한 시간이 0이 되도록 하려면 시간 제한 0 (0)으로 호출 receive 하는 것과 달리 try_receive 함수를 사용해야 합니다. 이 함수는 더 효율적이며 시간 제한 시 예외를 throw하지 않기 때문에 사용해야 합니다.

자세한 내용은 메시지 전달 함수를 참조 하세요.

run_with_cancellation_token

지정된 취소 토큰의 컨텍스트에서 동기적으로 즉시 함수 개체를 실행합니다.

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

매개 변수

_함수
호출될 함수 개체의 형식입니다.

_Func
실행될 함수 개체입니다. 이 개체는 void(void)의 시그니처가 있는 함수 호출 연산자를 지원해야 합니다.

_코네티컷
함수 객체의 암시 취소를 제어하는 취소 토큰입니다. 취소 중인 부모 작업 그룹에서 암시적 취소의 가능성 없이 함수 실행을 원할 경우 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
데이터가 전송되는 대상에 대한 포인터 또는 참조입니다.

_데이터
보낼 데이터에 대한 참조입니다.

Return Value

true 메시지가 수락 false 되었으면 그렇지 않습니다.

설명

자세한 내용은 메시지 전달 함수를 참조 하세요.

set_ambient_scheduler

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

매개 변수

_스케줄러
설정할 앰비언트 스케줄러입니다.

set_task_execution_resources

동시성 런타임 내부 작업자 스레드가 사용하는 실행 리소스를 지정된 선호도 집합으로 제한합니다.

리소스 관리자가 생성되기 전이나 두 리소스 관리자 수명 사이에만 이 메서드를 호출할 수 있습니다. 리소스 관리자가 호출 시 존재하지 않는 한 여러 번 호출할 수 있습니다. 선호도 제한이 설정된 후에는 다음 유효한 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
GROUP_AFFINITY 매개 변수로 지정된 배열에서 _PGroupAffinity 항목의 수입니다.

_PGroupAffinity
GROUP_AFFINITY 항목의 배열입니다.

설명

이 메서드는 호출될 때 Resource Manager가 있는 경우 invalid_operation 예외를 throw하고, 선호도 지정으로 인해 빈 리소스 집합이 발생하는 경우 invalid_argument 예외가 발생합니다.

매개 변수로 그룹 선호도 배열을 사용하는 이 메서드 버전은 Windows 7 이상과 운영 체제에서만 사용해야 합니다. 그렇지 않으면 invalid_operation 예외가 throw됩니다.

이 메서드가 호출된 후 프로세스 선호도를 프로그래밍 방식으로 수정해도 Resource Manager에서 제한되는 선호도를 다시 평가하지는 않습니다. 따라서 프로세스 선호도에 대한 모든 변경은 이 메서드를 호출하기 전에 해야 합니다.

swap

두 concurrent_vector 개체의 요소를 교환합니다.

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

매개 변수

T
동시 벡터에 저장된 요소의 데이터 형식입니다.

_도끼
동시 벡터의 할당자 형식입니다.

_A
요소가 동시 벡터의 요소와 교환될 동시 벡터 _B입니다.

_B
교환할 요소를 제공하는 동시 벡터 또는 해당 요소를 동시 벡터와 교환할 벡터 _A입니다.

설명

템플릿 함수는 멤버 함수_A를 실행하기 위해 컨테이너 클래스 concurrent_vector 에 특수화된 알고리즘입니다. concurrent_vector::swap( _B). 이러한 함수는 컴파일러에서 지정하는 함수 템플릿의 부분 순서 인스턴스입니다. 함수를 호출할 때 템플릿이 고유하게 일치하지 않는 방식으로 템플릿 함수가 오버로드되면 컴파일러는 템플릿 함수의 가장 특수화된 버전을 선택합니다. 알고리즘 클래스에서 템플릿 함수 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

_예외

_TaskOptions

Return Value

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

매개 변수

_Param

_TaskOptions

Return Value

Trace_agents_register_name

ETW 추적에서 메시지 블록 또는 에이전트에 지정된 이름을 연결합니다.

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

매개 변수

T
개체의 유형입니다. 일반적으로 메시지 블록 또는 에이전트입니다.

_PObject
추적에 명명된 에이전트 또는 메시지 블록에 대한 포인터입니다.

_이름
지정된 개체의 이름입니다.

try_receive

컨텍스트에서 정확히 한 소스의 데이터를 찾고 허용되는 값을 필터링할 수 있게 하는 일반 try-receive 구현입니다. 데이터가 준비되지 않으면 메서드가 반환 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
데이터가 필요한 원본에 대한 포인터 또는 참조입니다.

_값
결과가 배치될 위치에 대한 참조입니다.

_Filter_proc
메시지를 수락해야 하는지 여부를 결정하는 필터 함수입니다.

Return Value

bool 페이로드가 배치_value되었는지 여부를 나타내는 값입니다.

설명

자세한 내용은 메시지 전달 함수를 참조 하세요.

wait

지정된 시간 동안 현재 컨텍스트를 일시 중지합니다.

void __cdecl wait(unsigned int _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));

매개 변수

_반복기
입력 반복기의 형식입니다.

_시작
결과 작업으로 결합되는 요소 범위 내 첫 번째 요소의 위치입니다.

_끝
결과 작업으로 결합되는 요소 범위를 벗어나는 첫 번째 요소의 위치입니다.

_TaskOptions
task_options 개체

Return Value

모든 입력 작업이 성공적으로 완료되면 성공적으로 완료되는 작업입니다. 입력 작업이 T 형식이면 이 함수의 출력은 task<std::vector<T>>가 됩니다. 입력 작업이 void 형식이면 이 함수의 출력 작업도 task<void>가 됩니다.

설명

when_all은 task를 해당 결과로 생성하는 비블로킹 함수입니다. task::wait와 달리 ASTA(Application STA) 스레드의 UWP 앱에서 이 함수를 호출하는 것이 안전합니다.

작업 중 하나가 취소되거나 예외를 throw하면 반환된 작업이 취소된 상태에서 일찍 완료되고, 작업::get 또는 task::wait 해당 태스크를 호출하면 예외가 throw됩니다.

자세한 내용은 작업 병렬 처리를 참조하세요.

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
반환된 작업의 취소를 제어하는 취소 토큰입니다. 취소 토큰을 제공하지 않으면 결과 작업은 작업의 취소 토큰을 받으므로 완료됩니다.

Return Value

두 입력 작업 중 하나라도 성공적으로 완료되는 경우 완료되는 작업입니다. 입력 작업이 T 형식이면 이 함수의 출력은 task<std::pair<T, size_t>>>이 되며, 여기서 쌍의 첫 번째 요소는 완료되는 작업의 결과이고 두 번째 요소는 완료된 작업의 인덱스입니다. 입력 작업이 void 형식이면 출력은 task<size_t>이 됩니다. 여기서 결과는 완료되는 작업의 인덱스입니다.

설명

when_any은 task를 해당 결과로 생성하는 비블로킹 함수입니다. task::wait와 달리 ASTA(Application STA) 스레드의 UWP 앱에서 이 함수를 호출하는 것이 안전합니다.

자세한 내용은 작업 병렬 처리를 참조하세요.

참고 항목

concurrency 네임스페이스