Concurrency::details::_TaskCollectionImpl Class Reference

#include <pplconcrt.h>

Public Types
typedef Concurrency::details::_TaskProcHandle	_TaskProcHandle_t

Public Member Functions
	_TaskCollectionImpl (::Concurrency::scheduler_ptr _PScheduler)
	~_TaskCollectionImpl ()
void	_ScheduleTask (_TaskProcHandle_t *_Parameter, _TaskInliningMode _InliningMode)
void	_Cancel ()
void	_RunAndWait ()
void	_Wait ()
void	_Complete ()
::Concurrency::scheduler_ptr	_GetScheduler () const

Static Public Member Functions
static void	_RunTask (TaskProc _Proc, void *_Parameter, _TaskInliningMode _InliningMode)
static bool __cdecl	_Is_cancellation_requested ()

Private Member Functions
void	_SetScheduled ()

Private Attributes
::Concurrency::extensibility::event_t	_M_Scheduled
::Concurrency::extensibility::event_t	_M_Completed
_AsyncTaskCollection *	_M_pTaskCollection
::Concurrency::scheduler_ptr	_M_pScheduler

Member Typedef Documentation

typedef Concurrency::details::_TaskProcHandle Concurrency::details::_TaskCollectionImpl::_TaskProcHandle_t

Constructor & Destructor Documentation

Concurrency::details::_TaskCollectionImpl::_TaskCollectionImpl ( ::Concurrency::scheduler_ptr  _PScheduler )

inline

            : _M_pTaskCollection(nullptr), _M_pScheduler(_PScheduler)
        {
        }

Concurrency::details::_TaskCollectionImpl::~_TaskCollectionImpl ( )

inline

        {
            if (_M_pTaskCollection != nullptr)
            {
                _M_pTaskCollection->_Release();
                _M_pTaskCollection = nullptr;
            }
        }

Member Function Documentation

void Concurrency::details::_TaskCollectionImpl::_Cancel ( )

inline

        {
            // Ensure that RunAndWait makes progress.
            _SetScheduled();

            if (_M_pTaskCollection != nullptr)
            {
                _M_pTaskCollection->_Cancel();
            }
        }

void Concurrency::details::_TaskCollectionImpl::_Complete ( )

inline

        {
            // Ensure that RunAndWait makes progress.
            _SetScheduled();
            _M_Completed.set();
        }

::Concurrency::scheduler_ptr Concurrency::details::_TaskCollectionImpl::_GetScheduler ( ) const

inline

        {
            return _M_pScheduler;
        }

static bool __cdecl Concurrency::details::_TaskCollectionImpl::_Is_cancellation_requested ( )

inlinestatic

        {
            // ConcRT scheduler under the hood is using TaskCollection, which is same as task_group
            return ::Concurrency::is_current_task_group_canceling();
        }

void Concurrency::details::_TaskCollectionImpl::_RunAndWait ( )

inline

        {
            _M_Scheduled.wait();

            if (_M_pTaskCollection != nullptr)
            {
                // When it returns cancelled, either work chore or the cancel thread should already have set task's state
                // properly -- cancelled state or completed state (because there was no interruption point). 
                // For tasks with unwrapped tasks, we should not change the state of current task, since the unwrapped task are still running.
                _M_pTaskCollection->_RunAndWait();
            }
            else
            {
                _M_Completed.wait();
            }
        }

static void Concurrency::details::_TaskCollectionImpl::_RunTask ( TaskProc  _Proc, void *  _Parameter, _TaskInliningMode  _InliningMode  )

inlinestatic

        {
            Concurrency::details::_StackGuard _Guard;

            if (_Guard._ShouldInline(_InliningMode))
            {
                _Proc(_Parameter);
            }
            else
            {
                // Schedule the work on the current scheduler
                _CurrentScheduler::_ScheduleTask(_Proc, _Parameter);
            }
        }

void Concurrency::details::_TaskCollectionImpl::_ScheduleTask ( _TaskProcHandle_t *  _Parameter, _TaskInliningMode  _InliningMode  )

inline

        {
            if (!_M_pScheduler)
            {
                // Construct the task collection; We use none token to provent it becoming interruption point.
                _M_pTaskCollection = _AsyncTaskCollection::_NewCollection(::Concurrency::details::_CancellationTokenState::_None());
            }

            try 
            {
                if (_M_pTaskCollection != nullptr)
                {
                    // Do not need to check its returning state, more details please refer to _Wait method.
                    auto _PChore = static_cast< ::Concurrency::details::_UnrealizedChore*>(_Parameter);
                    _M_pTaskCollection->_ScheduleWithAutoInline(_PChore, _InliningMode);
                }
                else
                {
                    // Schedule the work on the user provided scheduler
                    if (_InliningMode == _ForceInline)
                    {
                        _TaskProcHandle_t::_RunChoreBridge(_Parameter);
                    }
                    else
                    {
                        _M_pScheduler->schedule(_TaskProcHandle_t::_RunChoreBridge, _Parameter);
                    }
                }
            }
            catch(...)
            {
                _SetScheduled();
                throw;
            }

            // Set the event in case anyone is waiting to notify that this task has been scheduled. In the case where we
            // execute the chore inline, the event should be set after the chore has executed, to prevent a different thread 
            // performing a wait on the task from waiting on the task collection before the chore is actually added to it, 
            // and thereby returning from the wait() before the chore has executed.
            _SetScheduled();
        }

void Concurrency::details::_TaskCollectionImpl::_SetScheduled ( )

inlineprivate

        {
            _M_Scheduled.set();
        }

void Concurrency::details::_TaskCollectionImpl::_Wait ( )

inline

        {
            _M_Completed.wait();
        }

Member Data Documentation

::Concurrency::extensibility::event_t Concurrency::details::_TaskCollectionImpl::_M_Completed

private

::Concurrency::scheduler_ptr Concurrency::details::_TaskCollectionImpl::_M_pScheduler

private

_AsyncTaskCollection* Concurrency::details::_TaskCollectionImpl::_M_pTaskCollection

private

::Concurrency::extensibility::event_t Concurrency::details::_TaskCollectionImpl::_M_Scheduled

private

---

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

• VS2013/inc/pplconcrt.h