concurrency 네임스페이스 함수concurrency namespace functions

#C4Alloc

동시성 런타임 캐싱 하위 할당기에서 지정된 크기의 메모리 블록을 할당합니다.Allocates a block of memory of the size specified from the Concurrency Runtime Caching Suballocator.

void* __cdecl Alloc(size_t _NumBytes);

매개 변수Parameters

_NumBytes_NumBytes
할당할 메모리의 바이트 수입니다.The number of bytes of memory to allocate.

반환 값Return Value

새로 할당 된 메모리에 대 한 포인터입니다.A pointer to newly allocated memory.

설명Remarks

캐싱 캐싱을 사용 하 여 응용 프로그램에서 어떤 시나리오를 사용할 수 있는지에 대 한 자세한 내용은 작업 스케줄러를 참조 하세요.For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler.

asendasend

대상 블록에 데이터를 전파하는 작업을 예약하는 비동기 전송 작업입니다.An asynchronous send operation, which schedules a task to propagate the data to the target block.

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

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

매개 변수Parameters

TT
보낼 데이터의 형식입니다.The type of the data to be sent.

_Trg_Trg
데이터가 전송 되는 대상에 대 한 포인터 또는 참조입니다.A pointer or reference to the target to which data is sent.

_Data_Data
보낼 데이터에 대 한 참조입니다.A reference to the data to be sent.

반환 값Return Value

true 메서드가 반환 되기 전에 메시지를 수락 하면이 고, false 그렇지 않으면입니다.true if the message was accepted before the method returned, false otherwise.

설명Remarks

자세한 내용은 메시지 전달 함수를 참조 하세요.For more information, see Message Passing Functions.

cancel_current_taskcancel_current_task

현재 실행 중인 작업을 취소합니다.Cancels the currently executing task. 이 함수는 작업 실행을 중단하도록 작업 본문 내에서 호출될 수 있으며 canceled 상태로 들어가도록 할 수 있습니다.This function can be called from within the body of a task to abort the task's execution and cause it to enter the canceled state.

task의 본문에 없는 경우에 이 함수를 호출하는 것은 지원되는 시나리오가 아닙니다.It is not a supported scenario to call this function if you are not within the body of a task. 이렇게 하면 응용 프로그램에서 충돌 또는 응답 하지 않는 등의 정의 되지 않은 동작이 발생 합니다.Doing so will result in undefined behavior such as a crash or unresponsiveness in your application.

inline __declspec(noreturn) void __cdecl cancel_current_task();

해제clear

현재 큐에 있는 모든 요소를 삭제 하 여 동시 큐를 지웁니다.Clears the concurrent queue, destroying any currently enqueued elements. 이 메서드는 동시성이 보장 되지 않습니다.This method is not concurrency-safe.

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

매개 변수Parameters

TT

_Ax_Ax

create_asynccreate_async

사용자가 제공한 람다 또는 함수 개체를 기준으로 Windows 런타임 비동기 구문을 만듭니다.Creates a Windows Runtime asynchronous construct based on a user supplied lambda or function object. create_async의 반환 형식은 메서드에 전달된 람다의 시그니처에 따라 IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ 또는 IAsyncOperationWithProgress<TResult, TProgress>^ 중 하나입니다.The return type of create_async is one of either IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, or IAsyncOperationWithProgress<TResult, TProgress>^ based on the signature of the lambda passed to the method.

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

매개 변수Parameters

_Function_Function
을 입력한 다음Type.

_Func_Func
Windows 런타임 비동기 구문을 만들 람다 또는 함수 개체입니다.The lambda or function object from which to create a Windows Runtime asynchronous construct.

반환 값Return Value

IAsyncAction ^, IAsyncActionWithProgress <TProgress> ^, iasyncoperation <TResult> ^ 또는 IAsyncOperationWithProgress ^로 표시 되는 비동기 구문 <TResult, TProgress> 입니다.An asynchronous construct represented by an IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, or an IAsyncOperationWithProgress<TResult, TProgress>^. 반환된 인터페이스는 함수에 전달되는 람다의 시그니처에 종속됩니다.The interface returned depends on the signature of the lambda passed into the function.

설명Remarks

람다의 반환 형식은 구문이 동작 또는 작업인지 여부를 결정합니다.The return type of the lambda determines whether the construct is an action or an operation.

void를 반환하는 람다는 작업을 생성합니다.Lambdas that return void cause the creation of actions. TResult 형식의 결과를 반환하는 람다는 TResult 작업을 생성합니다.Lambdas that return a result of type TResult cause the creation of operations of TResult.

람다는 비동기 작업을 자체 내에 캡슐화하거나 비동기 작업을 나타내는 연속 작업 체인인 task<TResult>를 반환할 수도 있습니다.The lambda may also return a task<TResult> which encapsulates the aysnchronous work within itself or is the continuation of a chain of tasks that represent the asynchronous work. 이 경우 작업은 비동기적으로 실행되므로 람다 자체가 인라인으로 실행되며, 람다의 반환 형식은 래핑이 해제되어 create_async에서 반환된 비동기 구문을 생성합니다.In this case, the lambda itself is executed inline, since the tasks are the ones that execute asynchronously, and the return type of the lambda is unwrapped to produce the asynchronous construct returned by create_async. 즉, 작업을 반환 하는 람다는 작업 <void> 을 생성 하 고, 작업을 반환 하는 람다는 TResult 작업을 생성 하 게 됩니다 <TResult> .This implies that a lambda that returns a task<void> will cause the creation of actions, and a lambda that returns a task<TResult> will cause the creation of operations of TResult.

람다는 0개, 하나 또는 두 개의 인수를 사용할 수 있습니다.The lambda may take either zero, one or two arguments. 해당 순서로 함께 사용되는 경우 올바른 인수는 progress_reporter<TProgress>cancellation_token입니다.The valid arguments are progress_reporter<TProgress> and cancellation_token, in that order if both are used. 인수가 없는 람다를 사용하면 진행률을 보고할 수 없는 비동기 구문이 생성됩니다.A lambda without arguments causes the creation of an asynchronous construct without the capability for progress reporting. Progress_reporter를 사용 하는 람다는 <TProgress> create_async report progress_reporter 개체의 메서드가 호출 될 때마다 형식 tprogress의 진행률을 보고 하는 비동기 구문을 반환 합니다.A lambda that takes a progress_reporter<TProgress> will cause create_async to return an asynchronous construct which reports progress of type TProgress each time the report method of the progress_reporter object is called. cancellation_token을 사용하는 람다는 해당 토큰을 사용하여 취소 여부를 확인하거나 이 토큰이 생성하는 작업에 전달되어 비동기 구문의 취소가 이러한 작업의 취소를 발생시키도록 할 수 있습니다.A lambda that takes a cancellation_token may use that token to check for cancellation, or pass it to tasks that it creates so that cancellation of the asynchronous construct causes cancellation of those tasks.

람다 또는 함수 개체의 본문이 작업 (task)이 아닌 결과를 반환 하는 경우 <TResult> 람다는 런타임이 암시적으로 만드는 작업의 컨텍스트에서 프로세스 MTA 내에서 비동기적으로 실행 됩니다.If the body of the lambda or function object returns a result (and not a task<TResult>), the lamdba will be executed asynchronously within the process MTA in the context of a task the Runtime implicitly creates for it. IAsyncInfo::Cancel 메서드는 암시적 작업의 취소를 발생시킵니다.The IAsyncInfo::Cancel method will cause cancellation of the implicit task.

람다 본문이 작업을 반환하는 경우 람다는 인라인 실행됩니다. 그리고 람다가 cancellation_token 형식의 인수를 갖도록 선언함으로써 작업을 만들 때 해당 토큰을 전달하여 람다 내부에서 만든 모든 작업의 취소를 트리거할 수 있습니다.If the body of the lambda returns a task, the lamba executes inline, and by declaring the lambda to take an argument of type cancellation_token you can trigger cancellation of any tasks you create within the lambda by passing that token in when you create them. 생성된 비동기 작업 또는 동작에서 register_callback을 호출할 때 런타임에서 콜백을 호출하도록 토큰에 IAsyncInfo::Cancel 메서드를 사용할 수도 있습니다.You may also use the register_callback method on the token to cause the Runtime to invoke a callback when you call IAsyncInfo::Cancel on the async operation or action produced..

이 함수는 Windows 런타임 앱 에서만 사용할 수 있습니다.This function is only available to Windows Runtime apps.

CreateResourceManagerCreateResourceManager

동시성 런타임 리소스 관리자의 singleton 인스턴스를 나타내는 인터페이스를 반환합니다.Returns an interface that represents the singleton instance of the Concurrency Runtime's Resource Manager. 리소스 관리자는 서로 협력하려는 스케줄러에 리소스를 할당해야 합니다.The Resource Manager is responsible for assigning resources to schedulers that want to cooperate with each other.

IResourceManager* __cdecl CreateResourceManager();

반환 값Return Value

IResourceManager 인터페이스입니다.An IResourceManager interface.

설명Remarks

이 메서드에 대 한 여러 후속 호출에서 동일한 리소스 관리자 인스턴스를 반환 합니다.Multiple subsequent calls to this method will return the same instance of the Resource Manager. 메서드에 대 한 각 호출은 리소스 관리자의 참조 횟수를 증가 시키고, 스케줄러가 리소스 관리자와 통신 하는 경우 Iresourcemanager:: Release 메서드 호출과 일치 해야 합니다.Each call to the method increments a reference count on the Resource Manager, and must be matched with a call to the IResourceManager::Release method when your scheduler is done communicating with the Resource Manager.

동시성 런타임에서 운영 체제를 지원 하지 않는 경우 unsupported_os 이 throw 됩니다.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

create_taskcreate_task

PPL 작업 개체를 만듭니다.Creates a PPL task object. 작업 생성자를 사용하는 곳이면 어디에나 create_task를 사용할 수 있습니다.create_task can be used anywhere you would have used a task constructor. 작업을 만드는 동안 키워드를 사용할 수 있기 때문에 주로 편의를 위해 제공 됩니다 auto .It is provided mainly for convenience, because it allows use of the auto keyword while creating tasks.

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

매개 변수Parameters

TT
작업이 생성되는 매개 변수 형식입니다.The type of the parameter from which the task is to be constructed.

_ReturnType_ReturnType
을 입력한 다음Type.

_Param_Param
작업이 생성되는 매개 변수입니다.The parameter from which the task is to be constructed. task_completion_eventUWP 앱에서 작업을 사용 하는 경우 람다 또는 함수 개체, 개체, 다른 task 개체 또는 Windows:: Foundation:: IAsyncInfo 인터페이스 일 수 있습니다.This could be a lambda or function object, a task_completion_event object, a different task object, or a Windows::Foundation::IAsyncInfo interface if you are using tasks in your UWP app.

_TaskOptions_TaskOptions
작업 옵션입니다.The task options.

_Task_Task
만들 태스크입니다.The task to create.

반환 값Return Value

에서 유추 되는 형식의 새 작업입니다 T _Param .A new task of type T, that is inferred from _Param.

설명Remarks

첫 번째 오버 로드는 단일 매개 변수를 사용 하는 작업 생성자 처럼 동작 합니다.The first overload behaves like a task constructor that takes a single parameter.

두 번째 오버 로드는 새로 만든 작업에 제공 된 취소 토큰을 연결 합니다.The second overload associates the cancellation token provided with the newly created task. 이 오버 로드를 사용 하는 경우 task 첫 번째 매개 변수로 다른 개체를 전달할 수 없습니다.If you use this overload you are not allowed to pass in a different task object as the first parameter.

반환 된 작업의 형식은 첫 번째 매개 변수에서 함수로 유추 됩니다.The type of the returned task is inferred from the first parameter to the function. _Paramtask_completion_event<T> , task<T> 또는 형식 중 하나를 반환 하는 함수 이면 T task<T> 만들어진 작업의 형식은 task<T> 입니다.If _Param is a task_completion_event<T>, a task<T>, or a functor that returns either type T or task<T>, the type of the created task is task<T>.

UWP 앱에서 _Param 가 windows:: foundation:: iasyncoperation <T> ^ 또는 windows:: foundation:: IAsyncOperationWithProgress ^ 형식 이거나 <T,P> 이러한 형식 중 하나를 반환 하는 함수 이면 생성 된 작업은 형식입니다 task<T> .In a UWP app, if _Param is of type Windows::Foundation::IAsyncOperation<T>^ or Windows::Foundation::IAsyncOperationWithProgress<T,P>^, or a functor that returns either of those types, the created task will be of type task<T>. _Param가 windows:: foundation:: IAsyncAction ^ 또는 windows:: foundation:: IAsyncActionWithProgress ^ 형식 이거나 <P> 이러한 형식 중 하나를 반환 하는 함수 이면 만들어진 작업은 형식을 갖습니다 task<void> .If _Param is of type Windows::Foundation::IAsyncAction^ or Windows::Foundation::IAsyncActionWithProgress<P>^, or a functor that returns either of those types, the created task will have type task<void>.

DisableTracingDisableTracing

동시성 런타임에서 추적을 사용하지 않도록 설정합니다.Disables tracing in the Concurrency Runtime. ETW 추적이 기본적으로 등록되지 않으므로 이 함수는 사용되지 않습니다.This function is deprecated because ETW tracing is unregistered by default.

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

반환 값Return Value

추적이 올바르게 사용 하지 않도록 설정 된 경우 S_OK 이 반환 됩니다.If tracing was correctly disabled, S_OK is returned. 추적이 이전에 시작되지 않은 경우 E_NOT_STARTED가 반환됩니다.If tracing was not previously initiated, E_NOT_STARTED is returned

EnableTracingEnableTracing

동시성 런타임에서 추적을 사용하도록 설정합니다.Enables tracing in the Concurrency Runtime. 이제 ETW 추적이 기본적으로 설정되므로 이 함수는 사용되지 않습니다.This function is deprecated because ETW tracing is now on by default.

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

반환 값Return Value

추적이 올바르게 시작 된 경우 S_OK 가 반환 되 고, 그렇지 않으면 E_NOT_STARTED 이 반환 됩니다.If tracing was correctly initiated, S_OK is returned; otherwise, E_NOT_STARTED is returned.

늘릴Free

Alloc 메서드에 의해 동시성 런타임 캐싱 하위 할당자에 이전에 할당된 메모리 블록을 해제합니다.Releases a block of memory previously allocated by the Alloc method to the Concurrency Runtime Caching Suballocator.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

매개 변수Parameters

_PAllocation_PAllocation
해제할 메서드에 의해 이전에 할당 된 메모리에 대 한 포인터입니다 Alloc .A pointer to memory previously allocated by the Alloc method which is to be freed. 매개 변수가 _PAllocation 값으로 설정 된 경우 NULL 이 메서드는이를 무시 하 고 즉시 반환 합니다.If the parameter _PAllocation is set to the value NULL, this method will ignore it and return immediately.

설명Remarks

캐싱 캐싱을 사용 하 여 응용 프로그램에서 어떤 시나리오를 사용할 수 있는지에 대 한 자세한 내용은 작업 스케줄러를 참조 하세요.For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler.

get_ambient_schedulerget_ambient_scheduler

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

반환 값Return Value

GetExecutionContextIdGetExecutionContextId

IExecutionContext 인터페이스를 구현하는 실행 컨텍스트에 할당할 수 있는 고유 식별자를 반환합니다.Returns a unique identifier that can be assigned to an execution context that implements the IExecutionContext interface.

unsigned int __cdecl GetExecutionContextId();

반환 값Return Value

실행 컨텍스트에 대 한 고유 식별자입니다.A unique identifier for an execution context.

설명Remarks

IExecutionContext인터페이스를 리소스 관리자에서 제공 하는 메서드에 매개 변수로 전달 하기 전에이 메서드를 사용 하 여 실행 컨텍스트의 식별자를 가져옵니다.Use this method to obtain an identifier for your execution context before you pass an IExecutionContext interface as a parameter to any of the methods offered by the Resource Manager.

GetOSVersionGetOSVersion

운영 체제 버전을 반환합니다.Returns the operating system version.

IResourceManager::OSVersion __cdecl GetOSVersion();

반환 값Return Value

운영 체제를 나타내는 열거형 값입니다.An enumerated value representing the operating system.

설명Remarks

동시성 런타임에서 운영 체제를 지원 하지 않는 경우 unsupported_os 이 throw 됩니다.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetProcessorCountGetProcessorCount

기본 시스템의 하드웨어 스레드 수를 반환합니다.Returns the number of hardware threads on the underlying system.

unsigned int __cdecl GetProcessorCount();

반환 값Return Value

하드웨어 스레드 수입니다.The number of hardware threads.

설명Remarks

동시성 런타임에서 운영 체제를 지원 하지 않는 경우 unsupported_os 이 throw 됩니다.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetProcessorNodeCountGetProcessorNodeCount

기본 시스템의 NUMA 노드 또는 프로세서 패키지 수를 반환합니다.Returns the number of NUMA nodes or processor packages on the underlying system.

unsigned int __cdecl GetProcessorNodeCount();

반환 값Return Value

NUMA 노드 또는 프로세서 패키지 수입니다.The number of NUMA nodes or processor packages.

설명Remarks

시스템에 프로세서 패키지 보다 더 많은 NUMA 노드가 포함 되어 있으면 NUMA 노드의 수가 반환 되 고, 그렇지 않으면 프로세서 패키지 수가 반환 됩니다.If the system contains more NUMA nodes than processor packages, the number of NUMA nodes is returned, otherwise, the number of processor packages is returned.

동시성 런타임에서 운영 체제를 지원 하지 않는 경우 unsupported_os 이 throw 됩니다.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetSchedulerIdGetSchedulerId

IScheduler 인터페이스를 구현하는 스케줄러에 할당할 수 있는 고유 식별자를 반환합니다.Returns a unique identifier that can be assigned to a scheduler that implements the IScheduler interface.

unsigned int __cdecl GetSchedulerId();

반환 값Return Value

스케줄러에 대 한 고유 식별자입니다.A unique identifier for a scheduler.

설명Remarks

IScheduler인터페이스를 리소스 관리자에서 제공 하는 메서드에 매개 변수로 전달 하기 전에이 메서드를 사용 하 여 스케줄러에 대 한 식별자를 가져옵니다.Use this method to obtain an identifier for your scheduler before you pass an IScheduler interface as a parameter to any of the methods offered by the Resource Manager.

internal_assign_iteratorsinternal_assign_iterators

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

매개 변수Parameters

TT

_Ax_Ax

_I_I

firstfirst

lastlast

interruption_pointinterruption_point

취소를 위한 중단 지점을 만듭니다.Creates an interruption point for cancellation. 이 함수가 호출된 컨텍스트에서 취소가 진행 중이면 현재 실행 중인 병렬 작업의 실행을 중단하는 내부 예외가 발생합니다.If a cancellation is in progress in the context where this function is called, this will throw an internal exception that aborts the execution of the currently executing parallel work. 취소가 진행되고 있지 않으면 함수에서 아무 작업도 하지 않습니다.If cancellation is not in progress, the function does nothing.

inline void interruption_point();

설명Remarks

interruption_point() 함수에 의해 throw된 내부 취소 예외를 catch하면 안 됩니다.You should not catch the internal cancellation exception thrown by the interruption_point() function. 예외는 런타임에서 catch되어 처리되며, 예외를 catch하면 프로그램이 비정상적으로 동작할 수 있습니다.The exception will be caught and handled by the runtime, and catching it may cause your program to behave abnormally.

is_current_task_group_cancelingis_current_task_group_canceling

현재 컨텍스트에서 현재 인라인으로 실행 중인 작업 그룹이 활성 취소 중이거나 곧 취소되는지 여부를 나타내는 표시를 반환합니다.Returns an indication of whether the task group which is currently executing inline on the current context is in the midst of an active cancellation (or will be shortly). 현재 컨텍스트에서 현재 인라인으로 실행 중인 작업 그룹이 없으면이 false 반환 됩니다.Note that if there is no task group currently executing inline on the current context, false will be returned.

bool __cdecl is_current_task_group_canceling();

반환 값Return Value

true 현재 실행 중인 작업 그룹이 취소 되 면이 고, false 그렇지 않으면입니다.true if the task group which is currently executing is canceling, false otherwise.

설명Remarks

자세한 내용은 취소를 참조 하세요.For more information, see Cancellation.

make_choicemake_choice

선택적 choice 또는 Scheduler과 두 개 이상의 입력 소스로 ScheduleGroup 메시징 블록을 생성합니다.Constructs a choice messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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

매개 변수Parameters

T1T1
첫 번째 소스의 메시지 블록 형식입니다.The message block type of the first source.

T2T2
두 번째 소스의 메시지 블록 형식입니다.The message block type of the second source.

_PScheduler_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 choice 개체입니다.The Scheduler object within which the propagation task for the choice messaging block is scheduled.

_Item1_Item1
첫 번째 소스입니다.The first source.

_Item2_Item2
두 번째 소스입니다.The second source.

_Items_Items
추가적인 소스입니다.Additional sources.

_PScheduleGroup_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 choice 개체입니다.The ScheduleGroup object within which the propagation task for the choice messaging block is scheduled. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.The Scheduler object used is implied by the schedule group.

반환 값Return Value

두 개 이상의 입력 소스가 있는 choice 메시지 블록입니다.A choice message block with two or more input sources.

make_greedy_joinmake_greedy_join

선택적 greedy multitype_join 또는 Scheduler과 두 개 이상의 입력 소스로 ScheduleGroup 메시징 블록을 생성합니다.Constructs a greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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

매개 변수Parameters

T1T1
첫 번째 소스의 메시지 블록 형식입니다.The message block type of the first source.

T2T2
두 번째 소스의 메시지 블록 형식입니다.The message block type of the second source.

_PScheduler_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.The Scheduler object within which the propagation task for the multitype_join messaging block is scheduled.

_Item1_Item1
첫 번째 소스입니다.The first source.

_Item2_Item2
두 번째 소스입니다.The second source.

_Items_Items
추가적인 소스입니다.Additional sources.

_PScheduleGroup_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.The ScheduleGroup object within which the propagation task for the multitype_join messaging block is scheduled. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.The Scheduler object used is implied by the schedule group.

반환 값Return Value

두 개 이상의 입력 소스가 있는 greedy multitype_join 메시지 블록입니다.A greedy multitype_join message block with two or more input sources.

make_joinmake_join

선택적 non_greedy multitype_join 또는 Scheduler과 두 개 이상의 입력 소스로 ScheduleGroup 메시징 블록을 생성합니다.Constructs a non_greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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

매개 변수Parameters

T1T1
첫 번째 소스의 메시지 블록 형식입니다.The message block type of the first source.

T2T2
두 번째 소스의 메시지 블록 형식입니다.The message block type of the second source.

_PScheduler_PScheduler
Scheduler 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.The Scheduler object within which the propagation task for the multitype_join messaging block is scheduled.

_Item1_Item1
첫 번째 소스입니다.The first source.

_Item2_Item2
두 번째 소스입니다.The second source.

_Items_Items
추가적인 소스입니다.Additional sources.

_PScheduleGroup_PScheduleGroup
ScheduleGroup 메시징 블록의 전파 작업이 예약되는 multitype_join 개체입니다.The ScheduleGroup object within which the propagation task for the multitype_join messaging block is scheduled. 사용된 Scheduler 개체는 일정 그룹에서 암시됩니다.The Scheduler object used is implied by the schedule group.

반환 값Return Value

두 개 이상의 입력 소스가 있는 non_greedy multitype_join 메시지 블록입니다.A non_greedy multitype_join message block with two or more input sources.

make_taskmake_task

task_handle 개체를 만들기 위한 팩터리 메서드입니다.A factory method for creating a task_handle object.

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

매개 변수Parameters

_Function_Function
개체로 표시 되는 작업을 실행 하기 위해 호출 될 함수 개체의 형식입니다 task_handle .The type of the function object that will be invoked to execute the work represented by the task_handle object.

_Func_Func
개체로 표시 되는 작업을 실행 하기 위해 호출 되는 함수입니다 task_handle .The function that will be invoked to execute the work represented by the task_handle object. 이는 람다 함수, 함수에 대 한 포인터 또는 시그니처와 함께 함수 호출 연산자의 버전을 지 원하는 모든 개체 일 수 있습니다 void operator()() .This may be a lambda functor, a pointer to a function, or any object that supports a version of the function call operator with the signature void operator()().

반환 값Return Value

task_handle 개체입니다.A task_handle object.

설명Remarks

이 함수는 람다 task_handle 함수에 대 한 진정한 형식을 몰라도 개체를 만들 수 있으므로 람다 식으로 개체를 만들어야 하는 경우에 유용 합니다.This function is useful when you need to create a task_handle object with a lambda expression, because it allows you to create the object without knowing the true type of the lambda functor.

parallel_buffered_sortparallel_buffered_sort

지정 된 범위의 요소를 내림차순으로 정렬 하거나 이진 조건자로 지정한 정렬 기준에 따라 병렬로 정렬 합니다.Arranges the elements in a specified range into a non-descending order, or according to an ordering criterion specified by a binary predicate, in parallel. 이 함수는 O(n) 추가 공간이 필요하고 정렬되는 요소에 대한 기본 초기화를 요구한다는 점을 제외하고, 비교 기반의 불안정한 내부 정렬이라는 점에서 std::sort와 의미 체계가 비슷합니다.This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

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

매개 변수Parameters

_Random_iterator_Random_iterator
입력 범위의 반복기 형식입니다.The iterator type of the input range.

_Allocator_Allocator
C + + 표준 라이브러리 호환 메모리 할당자의 형식입니다.The type of a C++ Standard Library compatible memory allocator.

_Function_Function
이진 비교 연산자의 형식입니다.The type of the binary comparator.

_Begin_Begin
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Alloc_Alloc
C + + 표준 라이브러리와 호환 되는 메모리 할당자의 인스턴스입니다.An instance of a C++ Standard Library compatible memory allocator.

_Func_Func
순서에 따라 연속적인 요소에 대해 충족될 비교 조건을 정의하는 사용자 정의 조건자 함수 개체입니다.A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. 이진 조건자는 두 개의 인수를 사용 하 고 만족 true 하지 않을 경우를 반환 false 합니다.A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. 이 비교 함수는 시퀀스의 요소 쌍에 대해 엄밀히 약한 순서를 적용해야 합니다.This comparator function must impose a strict weak ordering on pairs of elements from the sequence.

_Chunk_size_Chunk_size
병렬 실행을 위해 두 개로 분할될 청크의 최소 크기입니다.The mimimum size of a chunk that will be split into two for parallel execution.

설명Remarks

모든 오버 로드에 n * sizeof(T) 는 추가 공간이 필요 합니다 n . 여기서은 정렬할 요소의 수이 고 T 은 요소 형식입니다.All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. 대부분의 경우 parallel_buffered_sort parallel_sort에 비해 성능이 향상 되 고, 사용 가능한 메모리가 있는 경우 parallel_sort를 통해 사용 해야 합니다.In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

이진 비교 연산자를 제공 하지 않는 경우에는 std::less 요소 형식이 연산자를 제공 해야 하는 기본로 사용 됩니다 operator<() .If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

할당자 형식 또는 인스턴스를 제공 하지 않으면 c + + 표준 라이브러리 메모리 할당자를 std::allocator<T> 사용 하 여 버퍼를 할당 합니다.If you do not supply an allocator type or instance, the C++ Standard Library memory allocator std::allocator<T> is used to allocate the buffer.

알고리즘은 입력 범위를 두 개의 청크로 나누고 이어서 각 청크를 병렬로 실행할 두 개의 하위 청크로 나눕니다.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. 선택적 인수를 _Chunk_size 사용 하 여 직렬로 < 크기의 청크를 처리 해야 한다는 것을 알고리즘에 지정할 수 있습니다 _Chunk_size .The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_forparallel_for

parallel_for는 일정 범위의 인덱스를 반복하고 각 반복 시 사용자가 제공한 함수를 병렬로 실행합니다.parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

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

매개 변수Parameters

_Index_type_Index_type
반복에 사용 되는 인덱스의 형식입니다.The type of the index being used for the iteration.

_Function_Function
각 반복에서 실행 되는 함수의 형식입니다.The type of the function that will be executed at each iteration.

_Partitioner_Partitioner
제공 된 범위를 분할 하는 데 사용 되는 파티 셔 너의 형식입니다.The type of the partitioner that is used to partition the supplied range.

firstfirst
반복에 포함할 첫 번째 인덱스입니다.The first index to be included in the iteration.

lastlast
반복에 포함할 마지막 인덱스 하나 다음의 인덱스입니다.The index one past the last index to be included in the iteration.

_Step_Step
에서로 반복 될 때를 단계별로 실행 하는 값 first last 입니다.The value by which to step when iterating from first to last. 단계는 양수 여야 합니다.The step must be positive. 단계가 1 보다 작은 경우 invalid_argument 이 throw 됩니다.invalid_argument is thrown if the step is less than 1.

_Func_Func
각 반복에서 실행할 함수입니다.The function to be executed at each iteration. 이는 람다 식, 함수 포인터 또는 시그니처와 함께 함수 호출 연산자의 버전을 지 원하는 모든 개체 일 수 있습니다 void operator()(_Index_type) .This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type).

_Part_Part
partitioner 개체에 대한 참조입니다.A reference to the partitioner object. 인수는 const auto_partitioner & , const static_partitioner & , simple_partitioner 또는 affinity_partitioner 중 하나일 수 있습니다 const simple_partitioner & affinity_partitioner & . affinity_partitioner 개체를 사용 하는 경우에는 참조가 const l-value 참조가 아니어야 하므로 알고리즘에서 이후 루프를 다시 사용 하기 위한 상태를 저장할 수 있습니다.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

설명Remarks

자세한 내용은 병렬 알고리즘을 참조 하세요.For more information, see Parallel Algorithms.

parallel_for_eachparallel_for_each

parallel_for_each는 범위 내의 각 요소에 지정된 함수를 병렬로 적용합니다.parallel_for_each applies a specified function to each element within a range, in parallel. 요소에 대한 반복이 병렬로 수행되고 반복 순서가 지정되지 않는다는 점을 제외하고 std 네임스페이스의 for_each 함수와 의미 체계가 같습니다.It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. _Func 인수는 operator()(T) 형식의 함수 호출 연산자를 지원해야 합니다. 여기서 T 매개 변수는 반복되는 컨테이너의 항목 형식입니다.The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over.

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

매개 변수Parameters

_Iterator_Iterator
컨테이너를 반복 하는 데 사용 되는 반복기의 형식입니다.The type of the iterator being used to iterate over the container.

_Function_Function
범위 내의 각 요소에 적용 될 함수의 형식입니다.The type of the function that will be applied to each element within the range.

_Partitioner_Partitioner
firstfirst
병렬 반복에 포함할 첫 번째 요소 위치의 주소를 지정 하는 반복기입니다.An iterator addressing the position of the first element to be included in parallel iteration.

lastlast
병렬 반복에 포함할 마지막 요소 하나 다음 위치의 주소를 지정 하는 반복기입니다.An iterator addressing the position one past the final element to be included in parallel iteration.

_Func_Func
범위의 각 요소에 적용 되는 사용자 정의 함수 개체입니다.A user-defined function object that is applied to each element in the range.

_Part_Part
partitioner 개체에 대한 참조입니다.A reference to the partitioner object. 인수는 const auto_partitioner & , const static_partitioner & , simple_partitioner 또는 affinity_partitioner 중 하나일 수 있습니다 const simple_partitioner & affinity_partitioner & . affinity_partitioner 개체를 사용 하는 경우에는 참조가 const l-value 참조가 아니어야 하므로 알고리즘에서 이후 루프를 다시 사용 하기 위한 상태를 저장할 수 있습니다.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

설명Remarks

명시적 파티 셔 너 없이 오버 로드에 대 한 auto_partitioner 사용 됩니다.auto_partitioner will be used for the overload without an explicit partitioner.

임의 액세스를 지원 하지 않는 반복기의 경우 auto_partitioner 만 지원 됩니다.For iterators that do not support random access, only auto_partitioner is supported.

자세한 내용은 병렬 알고리즘을 참조 하세요.For more information, see Parallel Algorithms.

parallel_invokeparallel_invoke

매개 변수로 제공된 함수 개체를 병렬로 실행하고 실행이 완료될 때까지 차단됩니다.Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 각 함수 개체는 람다 식, 함수에 대한 포인터 또는 void operator()() 서명을 사용하여 함수 호출 연산자를 지원하는 모든 개체일 수 있습니다.Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature 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);

매개 변수Parameters

_Function1_Function1
병렬로 실행 될 첫 번째 함수 개체의 형식입니다.The type of the first function object to be executed in parallel.

_Function2_Function2
병렬로 실행할 두 번째 함수 개체의 형식입니다.The type of the second function object to be executed in parallel.

_Function3_Function3
병렬로 실행할 세 번째 함수 개체의 형식입니다.The type of the third function object to be executed in parallel.

_Function4_Function4
병렬로 실행할 네 번째 함수 개체의 형식입니다.The type of the fourth function object to be executed in parallel.

_Function5_Function5
병렬로 실행할 다섯 번째 함수 개체의 형식입니다.The type of the fifth function object to be executed in parallel.

_Function6_Function6
병렬로 실행할 여섯 번째 함수 개체의 형식입니다.The type of the sixth function object to be executed in parallel.

_Function7_Function7
병렬로 실행 되는 일곱 번째 함수 개체의 형식입니다.The type of the seventh function object to be executed in parallel.

_Function8_Function8
병렬로 실행 될 여덟 번째 함수 개체의 형식입니다.The type of the eighth function object to be executed in parallel.

_Function9_Function9
병렬로 실행할 아홉 번째 함수 개체의 형식입니다.The type of the ninth function object to be executed in parallel.

_Function10_Function10
병렬로 실행할 열 번째 함수 개체의 형식입니다.The type of the tenth function object to be executed in parallel.

_Func1_Func1
병렬로 실행 될 첫 번째 함수 개체입니다.The first function object to be executed in parallel.

_Func2_Func2
병렬로 실행할 두 번째 함수 개체입니다.The second function object to be executed in parallel.

_Func3_Func3
병렬로 실행할 세 번째 함수 개체입니다.The third function object to be executed in parallel.

_Func4_Func4
병렬로 실행할 네 번째 함수 개체입니다.The fourth function object to be executed in parallel.

_Func5_Func5
병렬로 실행할 다섯 번째 함수 개체입니다.The fifth function object to be executed in parallel.

_Func6_Func6
병렬로 실행할 여섯 번째 함수 개체입니다.The sixth function object to be executed in parallel.

_Func7_Func7
병렬로 실행 되는 일곱 번째 함수 개체입니다.The seventh function object to be executed in parallel.

_Func8_Func8
병렬로 실행 될 여덟 번째 함수 개체입니다.The eighth function object to be executed in parallel.

_Func9_Func9
병렬로 실행할 아홉 번째 함수 개체입니다.The ninth function object to be executed in parallel.

_Func10_Func10
병렬로 실행할 열 번째 함수 개체입니다.The tenth function object to be executed in parallel.

설명Remarks

매개 변수로 제공 되는 하나 이상의 함수 개체가 호출 컨텍스트에서 인라인으로 실행 될 수 있습니다.Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

이 함수에 매개 변수로 전달 되는 함수 개체 중 하나 이상이 예외를 throw 하는 경우 런타임은 이러한 예외 중 하나를 선택 하 여에 대 한 호출에서 전파 parallel_invoke 합니다.If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

자세한 내용은 병렬 알고리즘을 참조 하세요.For more information, see Parallel Algorithms.

parallel_radixsortparallel_radixsort

기수 정렬 알고리즘을 사용하여 지정된 범위의 요소를 비내림차순으로 정렬합니다.Arranges elements in a specified range into an non descending order using a radix sorting algorithm. 부호 없는 정수와 유사한 키로 정렬할 요소를 프로젝션할 수 있는 프로젝션 함수를 요구하는 안정적인 정렬 함수입니다.This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. 정렬되는 요소에 기본 초기화가 필요합니다.Default initialization is required for the elements being sorted.

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

매개 변수Parameters

_Random_iterator_Random_iterator
입력 범위의 반복기 형식입니다.The iterator type of the input range.

_Allocator_Allocator
C + + 표준 라이브러리 호환 메모리 할당자의 형식입니다.The type of a C++ Standard Library compatible memory allocator.

_Function_Function
프로젝션 함수의 형식입니다.The type of the projection function.

_Begin_Begin
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Alloc_Alloc
C + + 표준 라이브러리와 호환 되는 메모리 할당자의 인스턴스입니다.An instance of a C++ Standard Library compatible memory allocator.

_Proj_func_Proj_func
요소를 정수 계열 값으로 변환 하는 사용자 정의 프로젝션 함수 개체입니다.A user-defined projection function object that converts an element into an integral value.

_Chunk_size_Chunk_size
병렬 실행을 위해 두 개로 분할될 청크의 최소 크기입니다.The mimimum size of a chunk that will be split into two for parallel execution.

설명Remarks

모든 오버 로드에 n * sizeof(T) 는 추가 공간이 필요 합니다 n . 여기서은 정렬할 요소의 수이 고 T 은 요소 형식입니다.All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. 요소가 제공 될 때 키를 반환 하려면 서명이 있는 단항 프로젝션 함수를 사용 I _Proj_func(T) 해야 T 합니다. 여기서은 요소 형식이 고 I 는 부호 없는 정수 형식입니다.An unary projection functor with the signature I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

프로젝션 함수를 제공 하지 않으면 단순히 요소를 반환 하는 기본 프로젝션 함수가 정수 계열 형식에 사용 됩니다.If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. 프로젝션 함수가 없는 경우에는 요소가 정수 형식이 아닌 경우 함수가 컴파일되지 않습니다.The function will fail to compile if the element is not an integral type in the absence of a projection function.

할당자 형식 또는 인스턴스를 제공 하지 않으면 c + + 표준 라이브러리 메모리 할당자를 std::allocator<T> 사용 하 여 버퍼를 할당 합니다.If you do not supply an allocator type or instance, the C++ Standard Library memory allocator std::allocator<T> is used to allocate the buffer.

알고리즘은 입력 범위를 두 개의 청크로 나누고 이어서 각 청크를 병렬로 실행할 두 개의 하위 청크로 나눕니다.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. 선택적 인수를 _Chunk_size 사용 하 여 직렬로 < 크기의 청크를 처리 해야 한다는 것을 알고리즘에 지정할 수 있습니다 _Chunk_size .The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_reduceparallel_reduce

연속적 부분 합계를 계산하여 지정된 범위 내 모든 요소의 합계를 계산하거나, 합계 대신 지정된 이항 연산을 사용하여 유사하게 구한 연속적 부분 결과의 결과를 병렬로 계산합니다.Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce는 이항 연산이 결합형이어야 하고 초기 값 대신 ID 값을 요구한다는 점을 제외하고 std::accumulate와 의미 체계가 비슷합니다.parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value.

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

매개 변수Parameters

_Forward_iterator_Forward_iterator
입력 범위의 반복기 형식입니다.The iterator type of input range.

_Sym_reduce_fun_Sym_reduce_fun
대칭 감소 함수의 유형입니다.The type of the symmetric reduction function. 이는 시그니처가 포함 된 함수 형식 이어야 합니다 _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type) . 여기서 _Reduce_type은 id 형식 및 축소 결과 형식과 같습니다.This must be a function type with signature _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), where _Reduce_type is the same as the identity type and the result type of the reduction. 세 번째 오버 로드의 경우에는의 출력 형식과 일치 해야 합니다 _Range_reduce_fun .For the third overload, this should be consistent with the output type of _Range_reduce_fun.

_Reduce_type_Reduce_type
입력이 감소 하는 형식으로, 입력 요소 형식과 다를 수 있습니다.The type that the input will reduce to, which can be different from the input element type. 반환 값 및 id 값은이 형식을 갖습니다.The return value and identity value will has this type.

_Range_reduce_fun_Range_reduce_fun
범위 감소 함수의 유형입니다.The type of the range reduction function. 이는 시그니처가 있는 함수 형식 이어야 하며 _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type) , _Reduce_type은 id 형식 및 축소 결과 형식과 같습니다.This must be a function type with signature _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type is the same as the identity type and the result type of the reduction.

_Begin_Begin
축소할 범위의 첫 번째 요소를 주소 지정 하는 입력 반복기입니다.An input iterator addressing the first element in the range to be reduced.

_End_End
축소할 범위에서 마지막 요소 다음의 한 위치에 해당 하는 요소의 주소를 지정 하는 입력 반복기입니다.An input iterator addressing the element that is one position beyond the final element in the range to be reduced.

_Identity_Identity
Id 값의 _Identity 형식은 감소의 결과 형식과 동일 하며 value_type 첫 번째 및 두 번째 오버 로드에 대 한 반복기의도 같습니다.The identity value _Identity is of the same type as the result type of the reduction and also the value_type of the iterator for the first and second overloads. 세 번째 오버 로드의 경우 id 값은 축소 결과 형식과 동일한 형식 이어야 하지만 반복기의와 다를 수 있습니다 value_type .For the third overload, the identity value must have the same type as the result type of the reduction, but can be different from the value_type of the iterator. 이 값에는 range reduction 연산자가 _Range_fun 형식의 단일 요소 범위에 적용 될 때 value_type , 형식에서 value_type id 형식으로 값의 형식 캐스트 처럼 동작 하는 적절 한 값이 있어야 합니다.It must have an appropriate value such that the range reduction operator _Range_fun, when applied to a range of a single element of type value_type and the identity value, behaves like a type cast of the value from type value_type to the identity type.

_Sym_fun_Sym_fun
축소의 두 번째에 사용 되는 대칭 함수입니다.The symmetric function that will be used in the second of the reduction. 자세한 내용은 설명 부분을 참조 하십시오.Refer to Remarks for more information.

_Range_fun_Range_fun
축소의 첫 번째 단계에서 사용 되는 함수입니다.The function that will be used in the first phase of the reduction. 자세한 내용은 설명 부분을 참조 하십시오.Refer to Remarks for more information.

반환 값Return Value

축소의 결과입니다.The result of the reduction.

설명Remarks

병렬 감소를 수행 하기 위해 함수는 기본 스케줄러에서 사용할 수 있는 작업자 수를 기반으로 범위를 청크로 나눕니다.To perform a parallel reduction, the function divides the range into chunks based on the number of workers available to the underlying scheduler. 이러한 감소는 두 단계로 수행 되며, 첫 번째 단계는 각 청크 내에서 감소를 수행 하 고, 두 번째 단계는 각 청크의 부분 결과를 감소 시킵니다.The reduction takes place in two phases, the first phase performs a reduction within each chunk, and the second phase performs a reduction between the partial results from each chunk.

첫 번째 오버 로드를 사용 하려면 반복기의,이 (가) value_type T 감소 결과 형식 및 id 값 형식과 동일 해야 합니다.The first overload requires that the iterator's value_type, T, be the same as the identity value type as well as the reduction result type. 요소 형식 T는 T T::operator + (T) 각 청크의 요소를 줄이기 위해 연산자를 제공 해야 합니다.The element type T must provide the operator T T::operator + (T) to reduce elements in each chunk. 두 번째 단계 에서도 동일한 연산자가 사용 됩니다.The same operator is used in the second phase as well.

두 번째 오버 로드는 또한 반복기가 value_type id 값 형식과 동일 하 고 감소 결과 형식 이어야 합니다.The second overload also requires that the iterator's value_type be the same as the identity value type as well as the reduction result type. 제공 된 이항 연산자는 _Sym_fun 첫 번째 단계에 대 한 초기 값으로 id 값을 사용 하 여 두 축소 단계 모두에 사용 됩니다.The supplied binary operator _Sym_fun is used in both reduction phases, with the identity value as the initial value for the first phase.

세 번째 오버 로드의 경우 id 값 형식은 감소 결과 형식과 동일 해야 하지만 반복기의 값은 다를 수 value_type 있습니다.For the third overload, the identity value type must be the same as the reduction result type, but the iterator's value_type may be different from both. 범위 감소 함수는 _Range_fun 첫 번째 단계에서 id 값을 초기 값으로 사용 하 고 이항 함수는 _Sym_reduce_fun 두 번째 단계의 하위 결과에 적용 됩니다.The range reduction function _Range_fun is used in the first phase with the identity value as the initial value, and the binary function _Sym_reduce_fun is applied to sub results in the second phase.

parallel_sortparallel_sort

지정 된 범위의 요소를 내림차순으로 정렬 하거나 이진 조건자로 지정한 정렬 기준에 따라 병렬로 정렬 합니다.Arranges the elements in a specified range into a non-descending order, or according to an ordering criterion specified by a binary predicate, in parallel. 이 함수는 비교 기반의 불안정한 내부 정렬이라는 점에서 std::sort와 의미 체계가 비슷합니다.This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place 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);

매개 변수Parameters

_Random_iterator_Random_iterator
입력 범위의 반복기 형식입니다.The iterator type of the input range.

_Function_Function
이진 비교 구조 함수의 형식입니다.The type of the binary comparison functor.

_Begin_Begin
저장할 범위의 첫 번째 요소 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
저장할 범위의 마지막 요소 하나 다음 위치를 주소 지정하는 임의 액세스 반복기입니다.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Func_Func
순서에 따라 연속적인 요소에 대해 충족될 비교 조건을 정의하는 사용자 정의 조건자 함수 개체입니다.A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. 이진 조건자는 두 개의 인수를 사용 하 고 만족 true 하지 않을 경우를 반환 false 합니다.A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. 이 비교 함수는 시퀀스의 요소 쌍에 대해 엄밀히 약한 순서를 적용해야 합니다.This comparator function must impose a strict weak ordering on pairs of elements from the sequence.

_Chunk_size_Chunk_size
병렬 실행을 위해 두 개로 분할 되는 청크의 최소 크기입니다.The minimum size of a chunk that will be split into two for parallel execution.

설명Remarks

첫 번째 오버 로드는 이진 비교 연산자를 사용 합니다 std::less .The first overload uses the binary comparator std::less.

두 번째 오버로드는 bool _Func(T, T) 시그니처를 포함하는 제공된 이진 비교 연산자를 사용합니다. 여기서 T는 입력 범위 요소의 형식입니다.The second overloaded uses the supplied binary comparator that should have the signature bool _Func(T, T) where T is the type of the elements in the input range.

알고리즘은 입력 범위를 두 개의 청크로 나누고 이어서 각 청크를 병렬로 실행할 두 개의 하위 청크로 나눕니다.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. 선택적 인수를 _Chunk_size 사용 하 여 직렬로 < 크기의 청크를 처리 해야 한다는 것을 알고리즘에 지정할 수 있습니다 _Chunk_size .The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_transformparallel_transform

두 소스 범위에서 요소 쌍에 또는 소스 범위에 있는 각 요소에 지정된 함수 개체를 적용하고 대상 범위에 함수 개체의 반환 값을 병렬로 복사합니다.Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. 이 함수는 std::transform과 의미 체계가 같습니다.This functional is semantically equivalent to 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);

매개 변수Parameters

_Input_iterator1_Input_iterator1
첫 번째 입력 반복기 또는 유일한 입력 반복기의 형식입니다.The type of the first or only input iterator.

_Output_iterator_Output_iterator
출력 반복기의 형식입니다.The type of the output iterator.

_Unary_operator_Unary_operator
입력 범위의 각 요소에서 실행될 단항 구조 함수의 형식입니다.The type of the unary functor to be executed on each element in the input range.

_Input_iterator2_Input_iterator2
두 번째 입력 반복기의 형식입니다.The type of second input iterator.

_Binary_operator_Binary_operator
두 소스 범위의 요소에서 쌍 단위로 실행될 이진 구조 함수의 형식입니다.The type of the binary functor executed pairwise on elements from the two source ranges.

_Partitioner_Partitioner
first1first1
작업을 수행할 첫 번째 소스 범위 또는 유일한 소스 범위의 첫 번째 요소의 위치를 주소 지정하는 입력 반복기입니다.An input iterator addressing the position of the first element in the first or only source range to be operated on.

last1last1
작업을 수행할 첫 번째 소스 범위 또는 유일한 소스 범위에서 최종 요소의 하나 다음 위치를 주소 지정하는 입력 반복기입니다.An input iterator addressing the position one past the final element in the first or only source range to be operated on.

_Result_Result
대상 범위의 첫 번째 요소의 위치를 주소 지정하는 출력 반복기입니다.An output iterator addressing the position of the first element in the destination range.

_Unary_op_Unary_op
소스 범위의 각 요소에 적용되는 사용자 정의 단항 함수 개체입니다.A user-defined unary function object that is applied to each element in the source range.

_Part_Part
partitioner 개체에 대한 참조입니다.A reference to the partitioner object. 인수는 const auto_partitioner & , const static_partitioner & , simple_partitioner 또는 affinity_partitioner 중 하나일 수 있습니다 const simple_partitioner & affinity_partitioner & . affinity_partitioner 개체를 사용 하는 경우에는 참조가 const l-value 참조가 아니어야 하므로 알고리즘에서 이후 루프를 다시 사용 하기 위한 상태를 저장할 수 있습니다.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

first2first2
작업을 수행할 두 번째 소스 범위에서 첫 번째 요소의 위치를 주소 지정하는 입력 반복기입니다.An input iterator addressing the position of the first element in the second source range to be operated on.

_Binary_op_Binary_op
두 소스 범위에 쌍 단위 정방향으로 적용되는 사용자 정의 이진 함수 개체입니다.A user-defined binary function object that is applied pairwise, in a forward order, to the two source ranges.

반환 값Return Value

함수 개체에 의해 변형된 출력 요소를 받는 대상 범위에서 최종 요소의 하나 다음 위치를 주소 지정하는 출력 반복기입니다.An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

설명Remarks

명시적 파티 셔 너 인수가 없는 오버 로드에는 auto_partitioner 사용 됩니다.auto_partitioner will be used for the overloads without an explicit partitioner argument.

임의 액세스를 지원 하지 않는 반복기의 경우 auto_partitioner 만 지원 됩니다.For iterators that do not support random access, only auto_partitioner is supported.

_Unary_op 인수를 사용하는 오버로드는 입력 범위의 각 요소에 단항 구조 함수를 적용하여 입력 범위를 출력 범위로 변환합니다.The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_opoperator()(T) 시그니처를 포함하는 함수 호출 연산자를 지원해야 합니다. 여기서 T는 반복되는 범위의 값 형식입니다._Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

_Binary_op 인수를 사용하는 오버로드는 첫 번째 입력 범위의 한 요소와 두 번째 입력 범위의 한 요소에 이진 구조 함수를 적용하여 두 개의 입력 범위를 출력 범위로 변환합니다.The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_opoperator()(T, U) 시그니처를 포함하는 함수 호출 연산자를 지원해야 합니다. 여기서 T, U는 두 입력 반복기의 값 형식입니다._Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

자세한 내용은 병렬 알고리즘을 참조 하세요.For more information, see Parallel Algorithms.

받습니다receive

컨텍스트에서 정확히 한 소스의 데이터를 대기하고 허용되는 값을 필터링할 수 있게 하는 일반 receive 구현입니다.A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

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

매개 변수Parameters

TT
페이로드 유형입니다.The payload type.

_Src_Src
데이터가 필요한 소스에 대 한 포인터 또는 참조입니다.A pointer or reference to the source from which data is expected.

_Timeout_Timeout
메서드가 데이터에 대해 해야 하는 최대 시간 (밀리초)입니다.The maximum time for which the method should for the data, in milliseconds.

_Filter_proc_Filter_proc
메시지를 수락 해야 하는지 여부를 결정 하는 필터 함수입니다.A filter function which determines whether messages should be accepted.

반환 값Return Value

원본에서 페이로드 형식의 값입니다.A value from the source, of the payload type.

설명Remarks

매개 변수에 _Timeout 상수가 아닌 값이 있으면 COOPERATIVE_TIMEOUT_INFINITE 메시지가 수신 되기 전에 지정 된 시간이 만료 되 면 예외가 throw 됩니다 operation_timed_out .If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. 길이가 0 인 시간 제한이 필요한 경우 시간 제한 try_receive receive 0 (0)을 사용 하 여를 호출 하는 대신 try_receive 함수를 사용 해야 합니다.If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

자세한 내용은 메시지 전달 함수를 참조 하세요.For more information, see Message Passing Functions.

run_with_cancellation_tokenrun_with_cancellation_token

지정된 취소 토큰의 컨텍스트에서 동기적으로 즉시 함수 개체를 실행합니다.Executes a function object immediately and synchronously in the context of a given cancellation token.

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

매개 변수Parameters

_Function_Function
호출될 함수 개체의 형식입니다.The type of the function object that will be invoked.

_Func_Func
실행될 함수 개체입니다.The function object which will be executed. 이 개체는 void(void)의 시그니처가 있는 함수 호출 연산자를 지원해야 합니다.This object must support the function call operator with a signature of void(void).

_Ct_Ct
함수 객체의 암시 취소를 제어하는 취소 토큰입니다.The cancellation token which will control implicit cancellation of the function object. 취소 중인 부모 작업 그룹에서 암시적 취소의 가능성 없이 함수 실행을 원할 경우 cancellation_token::none()을 사용합니다.Use cancellation_token::none() if you want the function execute without any possibility of implicit cancellation from a parent task group being canceled.

설명Remarks

cancellation_token가 취소될 때 함수 개체의 중단점이 트리거됩니다.Any interruption points in the function object will be triggered when the cancellation_token is canceled. 명시적 토큰 _Ct는 부모에 다른 토큰이 있거나 토큰이 없는 경우 부모 취소로부터 _Func를 격리합니다.The explicit token _Ct will isolate this _Func from parent cancellation if the parent has a different token or no token.

보내기send

대상이 메시지를 수락 또는 거절할 때까지 기다리는 동기 전송 작업입니다.A synchronous send operation, which waits until the target either accepts or declines the message.

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

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

매개 변수Parameters

TT
페이로드 유형입니다.The payload type.

_Trg_Trg
데이터가 전송 되는 대상에 대 한 포인터 또는 참조입니다.A pointer or reference to the target to which data is sent.

_Data_Data
보낼 데이터에 대 한 참조입니다.A reference to the data to be sent.

반환 값Return Value

true 메시지가 수락 되었으면이 고, false 그렇지 않으면입니다.true if the message was accepted, false otherwise.

설명Remarks

자세한 내용은 메시지 전달 함수를 참조 하세요.For more information, see Message Passing Functions.

set_ambient_schedulerset_ambient_scheduler

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

매개 변수Parameters

_Scheduler_Scheduler
설정할 앰비언트 스케줄러입니다.The ambient scheduler to set.

set_task_execution_resourcesset_task_execution_resources

동시성 런타임 내부 작업자 스레드가 사용하는 실행 리소스를 지정된 선호도 집합으로 제한합니다.Restricts the execution resources used by the Concurrency Runtime internal worker threads to the affinity set specified.

리소스 관리자가 생성되기 전이나 두 리소스 관리자 수명 사이에만 이 메서드를 호출할 수 있습니다.It is valid to call this method only before the Resource Manager has been created, or between two Resource Manager lifetimes. 리소스 관리자가 호출 시 존재하지 않는 한 여러 번 호출할 수 있습니다.It can be invoked multiple times as long as the Resource Manager does not exist at the time of invocation. 선호도 제한이 설정된 후에는 다음 유효한 set_task_execution_resources 메서드 호출까지 적용된 상태로 유지됩니다.After an affinity limit has been set, it remains in effect until the next valid call to the set_task_execution_resources method.

제공된 선호도 마스크는 프로세스 선호도 마스크의 하위 집합이 아니어야 합니다.The affinity mask provided need not be a subset of the process affinity mask. 필요한 경우 프로세스 선호도가 업데이트됩니다.The process affinity will be updated if necessary.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

매개 변수Parameters

_ProcessAffinityMask_ProcessAffinityMask
동시성 런타임의 작업자 스레드를 제한할 선호도 마스크입니다.The affinity mask that the Concurrency Runtime worker threads are to be restricted to. 동시성 런타임을 현재 프로세서 그룹의 하위 집합으로 제한하려는 경우 하드웨어 스레드 수가 64개보다 많은 시스템에서만 이 메서드를 사용하십시오.Use this method on a system with greater than 64 hardware threads only if you want to limit the Concurrency Runtime to a subset of the current processor group. 하드웨어 스레드 수가 64개보다 많은 컴퓨터에서는 일반적으로 그룹 선호도 배열을 매개 변수로 사용하는 메서드 버전을 사용해야 합니다.In general, you should use the version of the method that accepts an array of group affinities as a parameter, to restrict affinity on machines with greater than 64 hardware threads.

countcount
GROUP_AFFINITY 매개 변수로 지정된 배열에서 _PGroupAffinity 항목의 수입니다.The number of GROUP_AFFINITY entries in the array specified by the parameter _PGroupAffinity.

_PGroupAffinity_PGroupAffinity
GROUP_AFFINITY 항목의 배열입니다.An array of GROUP_AFFINITY entries.

설명Remarks

메서드는 호출 될 때 리소스 관리자 있는 경우 invalid_operation 예외를 throw 하 고, 지정 된 선호도가 빈 리소스 집합을 생성 하는 경우에는 invalid_argument 예외를 발생 시킵니다.The method will throw an invalid_operation exception if a Resource Manager is present at the time it is invoked, and an invalid_argument exception if the affinity specified results in an empty set of resources.

매개 변수로 그룹 선호도 배열을 사용하는 이 메서드 버전은 Windows 7 이상과 운영 체제에서만 사용해야 합니다.The version of the method that takes an array of group affinities as a parameter should only be used on operating systems with version Windows 7 or higher. 그렇지 않으면 invalid_operation 예외가 throw 됩니다.Otherwise, an invalid_operation exception is thrown.

이 메서드가 호출 된 후에 프로세스 선호도를 프로그래밍 방식으로 수정 하면 리소스 관리자는 제한 된 선호도를 다시 평가 하지 않습니다.Programmatically modifying the process affinity after this method has been invoked will not cause the Resource Manager to re-evaluate the affinity it is restricted to. 따라서 프로세스 선호도에 대한 모든 변경은 이 메서드를 호출하기 전에 해야 합니다.Therefore, all changes to process affinity should be made before calling this method.

스왑을swap

concurrent_vector 개체의 요소를 교환합니다.Exchanges the elements of two concurrent_vector objects.

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

매개 변수Parameters

TT
동시 벡터에 저장 된 요소의 데이터 형식입니다.The data type of the elements stored in the concurrent vectors.

_Ax_Ax
동시 벡터의 할당자 형식입니다.The allocator type of the concurrent vectors.

_A_A
동시 벡터의 요소와 교환할 요소를 포함 하는 동시 벡터 _B 입니다.The concurrent vector whose elements are to be exchanged with those of the concurrent vector _B.

_B_B
교환할 요소를 제공 하는 동시 벡터 이거나, 동시 벡터와 요소를 교환할 벡터입니다 _A .The concurrent vector providing the elements to be swapped, or the vector whose elements are to be exchanged with those of the concurrent vector _A.

설명Remarks

템플릿 함수는 concurrent_vector 멤버 함수를 실행 하기 위해 컨테이너 클래스에서 특수화 된 알고리즘입니다 _A .The template function is an algorithm specialized on the container class concurrent_vector to execute the member function _A. concurrent_vector:: swap( _B ).concurrent_vector::swap( _B). 이러한 함수는 컴파일러에서 지정하는 함수 템플릿의 부분 순서 인스턴스입니다.These are instances of the partial ordering of function templates by the compiler. 함수를 호출할 때 템플릿이 고유하게 일치하지 않는 방식으로 템플릿 함수가 오버로드되면 컴파일러는 템플릿 함수의 가장 특수화된 버전을 선택합니다.When template functions are overloaded in such a way that the match of the template with the function call is not unique, then the compiler will select the most specialized version of the template function. 알고리즘 클래스에서 템플릿 함수의 일반 버전은 template <class T> void swap(T&, T&) 할당에 따라 작동 하 고 속도가 느립니다.The general version of the template function, template <class T> void swap(T&, T&), in the algorithm class works by assignment and is a slow operation. 각 컨테이너의 특수화된 버전은 컨테이너 클래스의 내부 표현을 사용할 수 있으므로 속도가 훨씬 빠릅니다.The specialized version in each container is much faster as it can work with the internal representation of the container class.

이 메서드는 동시성이 보장 되지 않습니다.This method is not concurrency-safe. 이 메서드를 호출할 때 다른 스레드가 동시 벡터 중 하나에서 작업을 수행 하 고 있지 않은지 확인 해야 합니다.You must ensure that no other threads are performing operations on either of the concurrent vectors when you call this method.

task_from_exceptiontask_from_exception

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

매개 변수Parameters

_TaskType_TaskType

_ExType_ExType

_Exception_Exception

_TaskOptions_TaskOptions

반환 값Return Value

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

매개 변수Parameters

TT

_Param_Param

_TaskOptions_TaskOptions

반환 값Return Value

Trace_agents_register_nameTrace_agents_register_name

ETW 추적에서 메시지 블록 또는 에이전트에 지정된 이름을 연결합니다.Associates the given name to the message block or agent in the ETW trace.

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

매개 변수Parameters

TT
개체의 형식입니다.The type of the object. 일반적으로 메시지 블록 또는 에이전트입니다.This is typically a message block or an agent.

_PObject_PObject
추적에 명명된 에이전트 또는 메시지 블록에 대한 포인터입니다.A pointer to the message block or agent that is being named in the trace.

_Name_Name
지정된 개체의 이름입니다.The name for the given object.

try_receivetry_receive

컨텍스트에서 정확히 한 소스의 데이터를 찾고 허용되는 값을 필터링할 수 있게 하는 일반 try-receive 구현입니다.A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. 데이터가 준비 되지 않은 경우이 메서드는를 반환 false 합니다.If the data is not ready, the method will return 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);

매개 변수Parameters

TT
페이로드 형식The payload type

_Src_Src
데이터가 필요한 소스에 대 한 포인터 또는 참조입니다.A pointer or reference to the source from which data is expected.

_value_value
결과가 배치 될 위치에 대 한 참조입니다.A reference to a location where the result will be placed.

_Filter_proc_Filter_proc
메시지를 수락 해야 하는지 여부를 결정 하는 필터 함수입니다.A filter function which determines whether messages should be accepted.

반환 값Return Value

bool 페이로드가 배치 되었는지 여부를 나타내는 값 _value 입니다.A bool value indicating whether or not a payload was placed in _value.

설명Remarks

자세한 내용은 메시지 전달 함수를 참조 하세요.For more information, see Message Passing Functions.

대기한wait

지정된 시간 동안 현재 컨텍스트를 일시 중지합니다.Pauses the current context for a specified amount of time.

void __cdecl wait(unsigned int _Milliseconds);

매개 변수Parameters

_Milliseconds_Milliseconds
현재 컨텍스트가 일시 중지되어야 하는 시간(밀리초)입니다.The number of milliseconds the current context should be paused for. _Milliseconds 매개 변수의 값이 0으로 설정된 경우 현재 컨텍스트는 계속하기 전에 다른 실행 가능한 컨텍스트에 실행을 양보해야 합니다.If the _Milliseconds parameter is set to the value 0, the current context should yield execution to other runnable contexts before continuing.

설명Remarks

이 메서드가 동시성 런타임 scheduler 컨텍스트에서 호출 되는 경우 스케줄러는 기본 리소스에서 실행 되는 다른 컨텍스트를 찾습니다.If this method is called on a Concurrency Runtime scheduler context, the scheduler will find a different context to run on the underlying resource. 스케줄러는 본질적으로 협조적이기 때문에 이 컨텍스트는 지정된 시간(밀리초) 후에 정확하게 다시 시작할 수 없습니다.Because the scheduler is cooperative in nature, this context cannot resume exactly after the number of milliseconds specified. 스케줄러가 스케줄러에 협조적으로 양보하지 않는 다른 작업을 실행 중인 경우 대기 기간이 무한할 수 있습니다.If the scheduler is busy executing other tasks that do not cooperatively yield to the scheduler, the wait period could be indefinite.

when_allwhen_all

인수로 제공된 모든 작업이 성공적으로 완료될 경우 완료되는 작업을 만듭니다.Creates a task that will complete successfully when all of the tasks supplied as arguments complete successfully.

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

매개 변수Parameters

_Iterator_Iterator
입력 반복기의 형식입니다.The type of the input iterator.

_Begin_Begin
결과 작업으로 결합되는 요소 범위 내 첫 번째 요소의 위치입니다.The position of the first element in the range of elements to be combined into the resulting task.

_End_End
결과 작업으로 결합되는 요소 범위를 벗어나는 첫 번째 요소의 위치입니다.The position of the first element beyond the range of elements to be combined into the resulting task.

_TaskOptions_TaskOptions
task_options 개체The task_options object.

반환 값Return Value

모든 입력 작업이 성공적으로 완료 되 면 성공적으로 완료 되는 작업입니다.A task that completes successfully when all of the input tasks have completed successfully. 입력 작업이 T 형식이면 이 함수의 출력은 task<std::vector<T>>가 됩니다.If the input tasks are of type T, the output of this function will be a task<std::vector<T>>. 입력 태스크가 형식이 면 void 출력 작업도이 됩니다 task<void> .If the input tasks are of type void the output task will also be a task<void>.

설명Remarks

when_alltask를 해당 결과로 생성하는 비블로킹 함수입니다.when_all is a non-blocking function that produces a task as its result. Task:: wait와 달리 ASTA (응용 프로그램 STA) 스레드의 UWP 앱에서이 함수를 호출 하는 것이 안전 합니다.Unlike task::wait, it is safe to call this function in a UWP app on the ASTA (Application STA) thread.

작업 중 하나가 취소 되거나 예외를 throw 하는 경우 반환 된 작업은 취소 된 상태에서 일찍 완료 되 고 작업 :: get 또는 task::wait 해당 작업에 대 한 예외가 발생 하면 예외가 throw 됩니다.If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, if one occurs, will be thrown if you call task::get or task::wait on that task.

자세한 내용은 작업 병렬 처리를 참조 하세요.For more information, see Task Parallelism.

when_anywhen_any

인수로 제공된 모든 작업이 성공적으로 완료될 경우 완료되는 작업을 만듭니다.Creates a task that will complete successfully when any of the tasks supplied as arguments completes successfully.

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

매개 변수Parameters

_Iterator_Iterator
입력 반복기의 형식입니다.The type of the input iterator.

_Begin_Begin
결과 작업으로 결합되는 요소 범위 내 첫 번째 요소의 위치입니다.The position of the first element in the range of elements to be combined into the resulting task.

_End_End
결과 작업으로 결합되는 요소 범위를 벗어나는 첫 번째 요소의 위치입니다.The position of the first element beyond the range of elements to be combined into the resulting task.

_TaskOptions_TaskOptions
_CancellationToken_CancellationToken
반환된 작업의 취소를 제어하는 취소 토큰입니다.The cancellation token which controls cancellation of the returned task. 취소 토큰을 제공하지 않으면 결과 작업은 작업의 취소 토큰을 받으므로 완료됩니다.If you do not provide a cancellation token, the resulting task will receive the cancellation token of the task that causes it to complete.

반환 값Return Value

두 입력 작업 중 하나라도 성공적으로 완료되는 경우 완료되는 작업입니다.A task that completes successfully when any one of the input tasks has completed successfully. 입력 작업이 T 형식이면 이 함수의 출력은 task<std::pair<T, size_t>>>이 되며, 여기서 쌍의 첫 번째 요소는 완료되는 작업의 결과이고 두 번째 요소는 완료된 작업의 인덱스입니다.If the input tasks are of type T, the output of this function will be a task<std::pair<T, size_t>>>, where the first element of the pair is the result of the completing task, and the second element is the index of the task that finished. 입력 태스크가 형식이 면 void 출력은입니다 task<size_t> . 여기서 결과는 완료 된 작업의 인덱스입니다.If the input tasks are of type void the output is a task<size_t>, where the result is the index of the completing task.

설명Remarks

when_anytask를 해당 결과로 생성하는 비블로킹 함수입니다.when_any is a non-blocking function that produces a task as its result. Task:: wait와 달리 ASTA (응용 프로그램 STA) 스레드의 UWP 앱에서이 함수를 호출 하는 것이 안전 합니다.Unlike task::wait, it is safe to call this function in a UWP app on the ASTA (Application STA) thread.

자세한 내용은 작업 병렬 처리를 참조 하세요.For more information, see Task Parallelism.

참고 항목See also

concurrency 네임 스페이스concurrency Namespace