Concurrency::details::_TaskCollectionBaseImpl Class Reference

#include <pplwin.h>

Public Types
typedef _TaskProcHandle	_TaskProcHandle_t

Public Member Functions
	_TaskCollectionBaseImpl (::Concurrency::scheduler_ptr _PScheduler)
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_t _Proc, void *_Parameter, _TaskInliningMode _InliningMode)

Protected Types
enum	_TaskCollectionState { _New, _Scheduled, _Completed }

Protected Member Functions
void	_SetCollectionState (_TaskCollectionState _NewState)
void	WaitUntilStateChangedTo (_TaskCollectionState _State)

Protected Attributes
::std::condition_variable	_M_StateChanged
::std::mutex	_M_Cs
::Concurrency::scheduler_ptr	_M_pScheduler
_TaskCollectionState	_M_State

Member Typedef Documentation

typedef _TaskProcHandle Concurrency::details::_TaskCollectionBaseImpl::_TaskProcHandle_t

Member Enumeration Documentation

enum Concurrency::details::_TaskCollectionBaseImpl::_TaskCollectionState

protected

Enumerator
_New
_Scheduled
_Completed

                                  {
            _New,
            _Scheduled,
            _Completed
        };

Constructor & Destructor Documentation

Concurrency::details::_TaskCollectionBaseImpl::_TaskCollectionBaseImpl ( ::Concurrency::scheduler_ptr  _PScheduler )

inline

            : _M_pScheduler(_PScheduler), _M_State(_New)
        {
        }

Member Function Documentation

void Concurrency::details::_TaskCollectionBaseImpl::_Cancel ( )

inline

        {
            // No cancellation support
        }

void Concurrency::details::_TaskCollectionBaseImpl::_Complete ( )

inline

        {
            // Ensure that RunAndWait makes progress.
            _SetCollectionState(_Completed);
        }

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

inline

        {
            return _M_pScheduler;
        }

void Concurrency::details::_TaskCollectionBaseImpl::_RunAndWait ( )

inline

        {
            _Wait();
        }

static void Concurrency::details::_TaskCollectionBaseImpl::_RunTask ( TaskProc_t  _Proc, void *  _Parameter, _TaskInliningMode  _InliningMode  )

inlinestatic

        {
            if (_InliningMode == _ForceInline)
            {
                _Proc(_Parameter);
            }
            else
            {
                // Schedule the work on the default scheduler if the ambient scheduler is not set
                auto _Ptr = get_ambient_scheduler();
                if (_Ptr)
                {
                    _Ptr->schedule(_Proc, _Parameter);
                }
                else
                {
                    _DefaultPPLTaskScheduler().schedule(_Proc, _Parameter);
                }
            }
        }

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

inline

        {
            if (_InliningMode == _ForceInline)
            {
                _TaskProcHandle_t::_RunChoreBridge(_Parameter);
            }
            else
            {
                if (_M_pScheduler)
                {
                    _M_pScheduler->schedule(_TaskProcHandle_t::_RunChoreBridge, _Parameter);
                }
                else
                {
                    _DefaultPPLTaskScheduler().schedule(_TaskProcHandle_t::_RunChoreBridge, _Parameter);
                }
            }
        }

void Concurrency::details::_TaskCollectionBaseImpl::_SetCollectionState ( _TaskCollectionState  _NewState )

inlineprotected

        {
            _ASSERTE(_NewState != _New);
            std::lock_guard<std::mutex> _Lock(_M_Cs);
            if (_M_State < _NewState)
            {
                _M_State = _NewState;
            }

            _M_StateChanged.notify_all();
        }

void Concurrency::details::_TaskCollectionBaseImpl::_Wait ( )

inline

        {
            WaitUntilStateChangedTo(_Completed);
        }

void Concurrency::details::_TaskCollectionBaseImpl::WaitUntilStateChangedTo ( _TaskCollectionState  _State )

inlineprotected

        {
            std::unique_lock<std::mutex> _Lock(_M_Cs);

            while(_M_State < _State)
            {
                _M_StateChanged.wait(_Lock);
            }
        }

Member Data Documentation

::std::mutex Concurrency::details::_TaskCollectionBaseImpl::_M_Cs

protected

::Concurrency::scheduler_ptr Concurrency::details::_TaskCollectionBaseImpl::_M_pScheduler

protected

_TaskCollectionState Concurrency::details::_TaskCollectionBaseImpl::_M_State

protected

::std::condition_variable Concurrency::details::_TaskCollectionBaseImpl::_M_StateChanged

protected

---

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

• VS2017/inc/pplwin.h