ppl.h File Reference

#include <crtdefs.h>
#include <concrt.h>
#include <stdexcept>
#include <iterator>
#include <functional>
#include <memory>
#include <type_traits>
#include <algorithm>
#include <malloc.h>
#include <pplwin.h>

Go to the source code of this file.

Classes
class	Concurrency::task_handle< _Function >
	The task_handle class represents an individual parallel work item. It encapsulates the instructions and the data required to execute a piece of work. More...
class	Concurrency::structured_task_group
	The structured_task_group class represents a highly structured collection of parallel work. You can queue individual parallel tasks to a structured_task_group using task_handle objects, and wait for them to complete, or cancel the task group before they have finished executing, which will abort any tasks that have not begun execution. More...
class	Concurrency::task_group
	The task_group class represents a collection of parallel work which can be waited on or canceled. More...
class	Concurrency::auto_partitioner
	The auto_partitioner class represents the default method parallel_for, parallel_for_each and parallel_transform use to partition the range they iterates over. This method of partitioning employes range stealing for load balancing as well as per-iterate cancellation. More...
class	Concurrency::static_partitioner
	The static_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into as many chunks as there are workers available to the underyling scheduler. More...
class	Concurrency::simple_partitioner
	The simple_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into chunks such that each chunk has at least the number of iterations specified by the chunk size. More...
class	Concurrency::affinity_partitioner
	The affinity_partitioner class is similar to the static_partitioner class, but it improves cache affinity by its choice of mapping subranges to worker threads. It can improve performance significantly when a loop is re-executed over the same data set, and the data fits in cache. Note that the same affinity_partitioner object must be used with subsequent iterations of a parallel loop that is executed over a particular data set, to benefit from data locality. More...
class	Concurrency::_Parallel_chunk_helper_invoke< _Random_iterator, _Index_type, _Function, _Is_iterator >
class	Concurrency::_Parallel_chunk_helper_invoke< _Random_iterator, _Index_type, _Function, false >
class	Concurrency::_Range< _Index_type >
class	Concurrency::_Worker_proxy< _Index_type >
class	Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >
class	Concurrency::_Parallel_fixed_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >
class	Concurrency::_Parallel_localized_chunk_helper< _Random_iterator, _Index_type, _Function, _Is_iterator >
class	Concurrency::_Parallel_for_each_helper< _Forward_iterator, _Function, _Chunk_size >
struct	Concurrency::_Reduce_functor_helper< _Reduce_type, _Sub_function, _Combinable_type >
class	Concurrency::_Order_combinable< _Ty, _Sym_fun >
struct	Concurrency::_Order_combinable< _Ty, _Sym_fun >::_Bucket
class	Concurrency::_Parallel_reduce_fixed_worker< _Forward_iterator, _Functor >
struct	Concurrency::_Parallel_reduce_forward_executor_helper< _Forward_iterator, _Function, _Default_worker_size, _Default_chunk_size >
struct	Concurrency::_Unary_transform_impl_helper< _Any_input_traits, _Any_output_traits >
struct	Concurrency::_Unary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag >
struct	Concurrency::_Binary_transform_impl_helper< _Any_input_traits1, _Any_input_traits2, _Any_output_traits >
struct	Concurrency::_Binary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag, std::random_access_iterator_tag >
class	Concurrency::_Iterator_helper< _Forward_iterator, _Iterator_kind >
class	Concurrency::_Iterator_helper< _Random_iterator, std::random_access_iterator_tag >
class	Concurrency::_Parallel_transform_binary_helper< _Input_iterator1, _Input_iterator2, _Output_iterator, _Binary_operator>
class	Concurrency::_Parallel_transform_unary_helper< _Input_iterator, _Output_iterator, _Unary_operator>
class	Concurrency::combinable< _Ty >
	The combinable<T> object is intended to provide thread-private copies of data, to perform lock-free thread-local sub-computations during parallel algorithms. At the end of the parallel operation, the thread-private sub-computations can then be merged into a final result. This class can be used instead of a shared variable, and can result in a performance improvement if there would otherwise be a lot of contention on that shared variable. More...
class	Concurrency::_AllocatedBufferHolder< _Allocator >
struct	Concurrency::_Radix_sort_default_function< _DataType >

Namespaces
	Concurrency
	The Concurrency namespace provides classes and functions that provide access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.
	Concurrency::details

Macros
#define	_PPL_H
#define	_TRACE_LEVEL_INFORMATION   4
#define	_MAX_NUM_TASKS_PER_CORE   1024
#define	_FINE_GRAIN_CHUNK_SIZE   512
#define	_SORT_MAX_RECURSION_DEPTH   64

Functions
_CONCRTIMP size_t __cdecl	Concurrency::details::_GetCombinableSize ()
template<class _Function >
task_handle< _Function >	Concurrency::make_task (const _Function &_Func)
	A factory method for creating a task_handle object. More...
template<typename _Function >
void	Concurrency::run_with_cancellation_token (const _Function &_Func, cancellation_token _Ct)
	Executes a function object immediately and synchronously in the context of a given cancellation token. More...
void	Concurrency::interruption_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. More...
_CONCRTIMP bool __cdecl	Concurrency::is_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). Note that if there is no task group currently executing inline on the current context, false will be returned. More...
template<typename _Function1 , typename _Function2 >
void	Concurrency::_Parallel_invoke_impl (const _Function1 &_Func1, const _Function2 &_Func2)
template<typename _Function1 , typename _Function2 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 >
void	Concurrency::parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6, const _Function7 &_Func7)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 >
void	Concurrency::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)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 >
void	Concurrency::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)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 , typename _Function10 >
void	Concurrency::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)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. 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()(). More...
template<typename _Worker_class , typename _Index_type , typename Partitioner >
void	Concurrency::_Parallel_chunk_task_group_run (structured_task_group &_Task_group, task_handle< _Worker_class > *_Chunk_helpers, const Partitioner &, _Index_type _I)
template<typename _Worker_class , typename _Index_type >
void	Concurrency::_Parallel_chunk_task_group_run (structured_task_group &_Task_group, task_handle< _Worker_class > *_Chunk_helpers, affinity_partitioner &_Part, _Index_type _I)
template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner >
void	Concurrency::_Parallel_chunk_impl (const _Random_iterator &_First, _Index_type _Range_arg, const _Index_type &_Step, const _Function &_Func, _Partitioner &&_Part)
template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function >
void	Concurrency::_Parallel_chunk_impl (const _Random_iterator &_First, _Index_type _Range_arg, const _Index_type &_Step, const _Function &_Func)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	Concurrency::_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const auto_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	Concurrency::_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const static_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	Concurrency::_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const simple_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	Concurrency::_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, affinity_partitioner &_Part)
template<typename _Index_type , typename _Function , typename _Partitioner >
void	Concurrency::_Parallel_for_impl (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func, _Partitioner &&_Part)
template<typename _Index_type , typename _Function >
void	Concurrency::_Parallel_for_impl (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func)
template<typename _Index_type , typename _Function , typename _Partitioner >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func, _Partitioner &&_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const auto_partitioner &_Part=auto_partitioner())
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const static_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const simple_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	Concurrency::parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, affinity_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Forward_iterator , typename _Function >
void	Concurrency::_Parallel_for_each_chunk (_Forward_iterator &_First, const _Forward_iterator &_Last, const _Function &_Func, task_group &_Task_group)
template<typename _Forward_iterator , typename _Function >
void	Concurrency::_Parallel_for_each_forward_impl (_Forward_iterator &_First, const _Forward_iterator &_Last, const _Function &_Func, task_group &_Task_group)
template<typename _Forward_iterator , typename _Function >
void	Concurrency::_Parallel_for_each_impl (_Forward_iterator _First, const _Forward_iterator &_Last, const _Function &_Func, const auto_partitioner &, std::forward_iterator_tag)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	Concurrency::_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const auto_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	Concurrency::_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const static_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	Concurrency::_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const simple_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	Concurrency::_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, affinity_partitioner &_Part)
template<typename _Random_iterator , typename _Function , typename _Partitioner >
void	Concurrency::_Parallel_for_each_impl (const _Random_iterator &_First, const _Random_iterator &_Last, const _Function &_Func, _Partitioner &&_Part, std::random_access_iterator_tag)
template<typename _Iterator , typename _Function >
void	Concurrency::parallel_for_each (_Iterator _First, _Iterator _Last, const _Function &_Func)
	parallel_for_each applies a specified function to each element within a range, in parallel. 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. 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. More...
template<typename _Iterator , typename _Function , typename _Partitioner >
void	Concurrency::parallel_for_each (_Iterator _First, _Iterator _Last, const _Function &_Func, _Partitioner &&_Part)
	parallel_for_each applies a specified function to each element within a range, in parallel. 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. 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. More...
template<typename _Reduce_type , typename _Forward_iterator , typename _Range_reduce_fun , typename _Sym_reduce_fun >
_Reduce_type	Concurrency::parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const _Reduce_type &_Identity, const _Range_reduce_fun &_Range_fun, const _Sym_reduce_fun &_Sym_fun)
	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 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. More...
template<typename _Forward_iterator , typename _Sym_reduce_fun >
std::iterator_traits< _Forward_iterator >::value_type	Concurrency::parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const typename std::iterator_traits< _Forward_iterator >::value_type &_Identity, _Sym_reduce_fun _Sym_fun)
	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 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. More...
template<typename _Forward_iterator >
std::iterator_traits< _Forward_iterator >::value_type	Concurrency::parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const typename std::iterator_traits< _Forward_iterator >::value_type &_Identity)
	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 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. More...
template<typename _Forward_iterator , typename _Function >
_Function::_Reduce_type	Concurrency::_Parallel_reduce_impl (_Forward_iterator _First, const _Forward_iterator &_Last, const _Function &_Func, std::forward_iterator_tag)
template<typename _Worker , typename _Random_iterator , typename _Function >
void	Concurrency::_Parallel_reduce_random_executor (_Random_iterator _Begin, _Random_iterator _End, const _Function &_Fun)
template<typename _Random_iterator , typename _Function >
_Function::_Reduce_type	Concurrency::_Parallel_reduce_impl (_Random_iterator _First, _Random_iterator _Last, const _Function &_Func, std::random_access_iterator_tag)
template<typename _Forward_iterator , typename _Function >
void	Concurrency::_Parallel_reduce_forward_executor (_Forward_iterator _First, _Forward_iterator _Last, const _Function &_Func, task_group &_Task_group)
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >
void	Concurrency::_Parallel_transform_binary_impl2 (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator &_Result, const _Binary_operator&_Binary_op, task_group &_Tg)
template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator >
void	Concurrency::_Parallel_transform_unary_impl2 (_Input_iterator _First, _Input_iterator _Last, _Output_iterator &_Result, const _Unary_operator&_Unary_op, task_group &_Tg)
template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator , typename _Partitioner >
_Output_iterator	Concurrency::_Parallel_transform_unary_impl (_Input_iterator _First, _Input_iterator _Last, _Output_iterator _Result, const _Unary_operator&_Unary_op, _Partitioner &&_Part)
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const auto_partitioner &_Part=auto_partitioner())
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const static_partitioner &_Part)
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const simple_partitioner &_Part)
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, affinity_partitioner &_Part)
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator , typename _Partitioner >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator _Result, const _Binary_operator&_Binary_op, _Partitioner &&_Part)
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >
_Output_iterator	Concurrency::parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator _Result, const _Binary_operator&_Binary_op)
	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. This functional is semantically equivalent to std::transform. More...
template<typename _Random_iterator , typename _Function >
size_t	Concurrency::_Median_of_three (const _Random_iterator &_Begin, size_t _A, size_t _B, size_t _C, const _Function &_Func, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Function >
size_t	Concurrency::_Median_of_nine (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Function >
size_t	Concurrency::_Select_median_pivot (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, const size_t _Chunk_size, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
size_t	Concurrency::_Search_mid_point (const _Random_iterator &_Begin1, size_t &_Len1, const _Random_buffer_iterator &_Begin2, size_t &_Len2, const _Function &_Func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >
void	Concurrency::_Merge_chunks (_Random_iterator _Begin1, const _Random_iterator &_End1, _Random_buffer_iterator _Begin2, const _Random_buffer_iterator &_End2, _Random_output_iterator _Output, const _Function &_Func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >
void	Concurrency::_Parallel_merge (_Random_iterator _Begin1, size_t _Len1, _Random_buffer_iterator _Begin2, size_t _Len2, _Random_output_iterator _Output, const _Function &_Func, size_t _Div_num)
template<typename _Ty , typename _Function >
size_t	Concurrency::_Radix_key (const _Ty &_Val, size_t _Radix, _Function _Proj_func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	Concurrency::_Integer_radix_pass (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	Concurrency::_Integer_radix_sort (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func, size_t _Deep=0)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	Concurrency::_Parallel_integer_radix_sort (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func, const size_t _Chunk_size, size_t _Deep=0)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	Concurrency::_Parallel_integer_sort_asc (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, _Function _Proj_func, const size_t _Chunk_size)
template<typename _Random_iterator , typename _Function >
void	Concurrency::_Parallel_quicksort_impl (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, size_t _Div_num, const size_t _Chunk_size, int _Depth)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
bool	Concurrency::_Parallel_buffered_sort_impl (const _Random_iterator &_Begin, size_t _Size, _Random_buffer_iterator _Output, const _Function &_Func, int _Div_num, const size_t _Chunk_size)
template<typename _Allocator >
_Allocator::pointer	Concurrency::_Construct_buffer (size_t _N, _Allocator &_Alloc)
template<typename _Allocator >
void	Concurrency::_Destroy_buffer (typename _Allocator::pointer _P, size_t _N, _Allocator &_Alloc)
template<typename _Random_iterator , typename _Function >
void	Concurrency::parallel_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort. More...
template<typename _Random_iterator >
void	Concurrency::parallel_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	Concurrency::parallel_buffered_sort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	Concurrency::parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Random_iterator , typename _Function >
void	Concurrency::parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Random_iterator >
void	Concurrency::parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Allocator , typename _Random_iterator >
void	Concurrency::parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Allocator , typename _Random_iterator >
void	Concurrency::parallel_buffered_sort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. 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. More...
template<typename _Random_iterator >
void	Concurrency::parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	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. More...
template<typename _Allocator , typename _Random_iterator >
void	Concurrency::parallel_radixsort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End)
	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. More...
template<typename _Allocator , typename _Random_iterator >
void	Concurrency::parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	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. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	Concurrency::parallel_radixsort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	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. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	Concurrency::parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	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. More...
template<typename _Random_iterator , typename _Function >
void	Concurrency::parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	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. More...

Macro Definition Documentation

#define _FINE_GRAIN_CHUNK_SIZE   512

#define _MAX_NUM_TASKS_PER_CORE   1024

#define _PPL_H

#define _SORT_MAX_RECURSION_DEPTH   64

#define _TRACE_LEVEL_INFORMATION   4