STLdoc: Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

#include <ppl.h>

Public Member Functions
	_Parallel_chunk_helper (_Index_type, const _Random_iterator &_First, _Index_type _First_iteration, _Index_type _Last_iteration, const _Index_type &_Step, const _Function &_Func, const _Partitioner &, _Worker_proxy< _Index_type > *const _Parent_data=NULL)

	_Parallel_chunk_helper (const _Random_iterator &_First, const _Index_type &_Step, const _Function &_Func, const _Range< _Index_type > &_Worker_range, _Worker_proxy< _Index_type > *const _Parent_data=NULL)

void	operator() () const

Private Member Functions
_Parallel_chunk_helper const &	operator= (_Parallel_chunk_helper const &)

Private Attributes
const _Random_iterator &	_M_first

const _Index_type &	_M_step

const _Function &	_M_function

const _Index_type	_M_first_iteration

const _Index_type	_M_last_iteration

_Worker_proxy< _Index_type > *const	_M_parent_worker

Constructor & Destructor Documentation

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_Parallel_chunk_helper	(	_Index_type	,
		const _Random_iterator &	_First,
		_Index_type	_First_iteration,
		_Index_type	_Last_iteration,
		const _Index_type &	_Step,
		const _Function &	_Func,
		const _Partitioner &	,
		_Worker_proxy< _Index_type > *const	_Parent_data = `NULL`
	)

inline

                                                                                                              :
         _M_first(_First), _M_first_iteration(_First_iteration), _M_last_iteration(_Last_iteration), _M_step(_Step), _M_function(_Func),
         _M_parent_worker(_Parent_data)
     {
         // Empty constructor because members are already assigned
     }

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_Parallel_chunk_helper	(	const _Random_iterator &	_First,
		const _Index_type &	_Step,
		const _Function &	_Func,
		const _Range< _Index_type > &	_Worker_range,
		_Worker_proxy< _Index_type > *const	_Parent_data = `NULL`
	)

inline

                                                                                                           :
         _M_first(_First), _M_first_iteration(_Worker_range._M_current_iteration), _M_last_iteration(_Worker_range._M_last_iteration), _M_step(_Step), _M_function(_Func),
         _M_parent_worker(_Parent_data)
     {
         // Empty constructor because members are already assigned
     }

Member Function Documentation

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

void Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::operator() ( ) const

inline

     {
         _Range<_Index_type> _Worker_range(_M_first_iteration, _M_last_iteration);
 
         // This class has two modes: worker and helper. The originally split chunk is always a
         // worker, while any subsequent class spawned from this class is in the helper
         // mode, which is signified using a link to the worker class through _M_pOwning_worker
         // handle. So, it will wait for work to be dished out by the working class while in helper mode.
         if (_M_parent_worker != NULL && !_M_parent_worker->_Receive_range(&_Worker_range))
         {
             // If the worker class rejected the help, simply return
             return;
         }
 
         // Keep the secondary, scaled, loop index for quick indexing into the data structure
         _Index_type _Current_iteration = _Worker_range._M_current_iteration;
         _Index_type _Scaled_index = _Current_iteration * _M_step;
 
         // If there is only one iteration to be executed there is no need to initialize any
         // helper classes (work is indivisible).
         if (_Worker_range._Number_of_iterations() == 1)
         {
             // Execute one iteration
             _Parallel_chunk_helper_invoke<_Random_iterator, _Index_type, _Function, _Is_iterator>::_Invoke(_M_first, _Scaled_index, _M_function);
             return;
         }
 
         // If the execution reaches this point it means that this class now has a chunk of work
         // that it needs to get done, so it has transitioned into the worker mode.
         structured_task_group _Helper_group;
 
         // Initialize fields that are needed in the helper
         _Worker_proxy<_Index_type> _Worker(_M_parent_worker);
 
         // Instantiate a helper class for this working class and put it on the work queue.
         // If some thread is idle it will be able to steal the helper and help this class
         // finish its work by stealing a piece of the work range.
         task_handle<_Parallel_chunk_helper> _Helper_task(_Parallel_chunk_helper(_M_first, _M_step, _M_function, _Worker_range, &_Worker));
 
         _Helper_group.run(_Helper_task);
 
         ::Concurrency::details::_MallocaListHolder<task_handle<_Parallel_chunk_helper>> _Holder;
 
         // Normally, for a cancellation semantic in cooperation with the helper, we would run_and_wait the below code on the Helper_group. Unfortunately,
         // the capture by reference of things which must be shared (_Worker, and so forth) will cause the loop below to add additional indirection
         // instructions. The loop below *MUST* be as tight as possible with the defined semantics. Instead, we will manually notify our parent if the
         // worker's destructor runs without hitting the bottom of our chunk. This is done through notification on the beacon.
 
         for (_Index_type _I = _Current_iteration; _I < _Worker_range._M_last_iteration; (_I++, _Worker_range._M_current_iteration =_I, _Scaled_index += _M_step))
         {
             if (_Worker._Is_beacon_signaled())
             {
                 // Either a parent task group is canceled or one of the other iterations
                 // threw an exception. Abort the remaining iterations
                 //
                 // Note that this could be a false positive that we must verify.
                 if (_Worker._Is_done() || _Worker._Verify_beacon_cancellation())
                 {
                     break;
                 }
             }
 
             if (_Worker._Is_helper_registered())
             {
                 // The helper class (there can only be one) registered to help this class with the work.
                 // Thus, figure out if this class needs help and split the range among the two classes.
 
                 if (_Worker._Send_range(&_Worker_range))
                 {
                     // Construct every new instance of a helper class on the stack because it is beneficial to use
                     // a structured task group where the class itself is responsible for task handle's lifetime.
                     task_handle<_Parallel_chunk_helper> * _Helper_subtask = _Holder._AddRawMallocaNode(_malloca(_Holder._GetAllocationSize()));
 
                     new(_Helper_subtask) task_handle<_Parallel_chunk_helper>
                         (_Parallel_chunk_helper(_M_first, _M_step, _M_function, _Worker_range, &_Worker));
 
                     // If _Send_range returns true, that means that there is still some non-trivial
                     // work to be done, so this class will potentially need another helper.
                     _Helper_group.run(*_Helper_subtask);
                 }
             }
 
             // Allow intrusive stealing by the helper
             _Worker._Enable_intrusive_steal(&_Worker_range);
 
             // Execute one iteration: the element is at scaled index away from the first element.
             _Parallel_chunk_helper_invoke<_Random_iterator, _Index_type, _Function, _Is_iterator>::_Invoke(_M_first, _Scaled_index, _M_function);
 
             // Helper shall not steal a range after this call
             _Worker._Disable_intrusive_steal();
         }
 
         // Indicate that the worker is done with its iterations.
         _Worker._Set_done();
 
         // Wait for all worker/helper iterations to finish
         _Helper_group.wait();
 
         // Make sure that we've signaled that the tree is complete. This is used to detect any exception out of either _Parallel_chunk_helper_invoke or
         // _Helper_group.wait() above as a cancellation of the loop which must propagate upwards because we do not wrap the loop body in run_and_wait.
         _Worker._Set_tree_done();
     }

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

_Parallel_chunk_helper const& Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::operator= ( _Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator > const & )

private

Member Data Documentation

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

const _Random_iterator& Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_first

private

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

const _Index_type Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_first_iteration

private

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

const _Function& Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_function

private

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

const _Index_type Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_last_iteration

private

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

_Worker_proxy<_Index_type>* const Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_parent_worker

private

template<typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner , bool _Is_iterator>

const _Index_type& Concurrency::_Parallel_chunk_helper< _Random_iterator, _Index_type, _Function, _Partitioner, _Is_iterator >::_M_step

private

The documentation for this class was generated from the following file:

VS2013/inc/ppl.h