Concurrency::details::_Task_impl_base Struct Reference

The base implementation of a first-class task. This class contains all the non-type specific implementation details of the task. More...

#include <ppltasks.h>

Inheritance diagram for Concurrency::details::_Task_impl_base:

Public Types
enum	_TaskInternalState {   _Created, _Started, _PendingCancel, _Completed,   _Canceled }
typedef _ContinuationTaskHandleBase *	_ContinuationList

Public Member Functions
	_Task_impl_base (_CancellationTokenState *_PTokenState, scheduler_ptr _Scheduler_arg)
virtual	~_Task_impl_base ()
task_status	_Wait ()
virtual bool	_CancelAndRunContinuations (bool _SynchronousCancel, bool _UserException, bool _PropagatedFromAncestor, const std::shared_ptr< _ExceptionHolder > &_ExHolder)=0
	Requests cancellation on the task and schedules continuations if the task can be transitioned to a terminal state. More...
bool	_Cancel (bool _SynchronousCancel)
bool	_CancelWithExceptionHolder (const std::shared_ptr< _ExceptionHolder > &_ExHolder, bool _PropagatedFromAncestor)
bool	_CancelWithException (const std::exception_ptr &_Exception)
void	_RegisterCancellation (std::weak_ptr< _Task_impl_base > _WeakPtr)
void	_DeregisterCancellation ()
bool	_IsCreated ()
bool	_IsStarted ()
bool	_IsPendingCancel ()
bool	_IsCompleted ()
bool	_IsCanceled ()
bool	_HasUserException ()
const std::shared_ptr< _ExceptionHolder > &	_GetExceptionHolder ()
bool	_IsApartmentAware ()
void	_SetAsync (bool _Async=true)
_TaskCreationCallstack	_GetTaskCreationCallstack ()
void	_SetTaskCreationCallstack (const _TaskCreationCallstack &_Callstack)
void	_ScheduleTask (_UnrealizedChore_t *_PTaskHandle, _TaskInliningMode_t _InliningMode)
	Helper function to schedule the task on the Task Collection. More...
void	_RunContinuation (_ContinuationTaskHandleBase *_PTaskHandle)
	Function executes a continuation. This function is recorded by a parent task implementation when a continuation is created in order to execute later. More...
void	_ScheduleContinuationTask (_ContinuationTaskHandleBase *_PTaskHandle)
void	_ScheduleContinuation (_ContinuationTaskHandleBase *_PTaskHandle)
	Schedule the actual continuation. This will either schedule the function on the continuation task's implementation if the task has completed or append it to a list of functions to execute when the task actually does complete. More...
void	_RunTaskContinuations ()
scheduler_ptr	_GetScheduler () const

Static Public Member Functions
static _CRTIMP2 bool __cdecl	_IsNonBlockingThread ()
template<typename _ReturnType , typename _InternalReturnType >
static void	_AsyncInit (const typename _Task_ptr< _ReturnType >::_Type &_OuterTask, const task< _InternalReturnType > &_UnwrappedTask)

Public Attributes
volatile _TaskInternalState	_M_TaskState
bool	_M_fFromAsync
bool	_M_fUnwrappedTask
std::shared_ptr< _ExceptionHolder >	_M_exceptionHolder
std::mutex	_M_ContinuationsCritSec
_ContinuationList	_M_Continuations
_CancellationTokenState *	_M_pTokenState
_CancellationTokenRegistration *	_M_pRegistration
::Concurrency::details::_TaskCollection_t	_M_TaskCollection
_TaskCreationCallstack	_M_pTaskCreationCallstack
_TaskEventLogger	_M_taskEventLogger

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

Detailed Description

The base implementation of a first-class task. This class contains all the non-type specific implementation details of the task.

Member Typedef Documentation

typedef _ContinuationTaskHandleBase* Concurrency::details::_Task_impl_base::_ContinuationList

Member Enumeration Documentation

enum Concurrency::details::_Task_impl_base::_TaskInternalState

Enumerator
_Created
_Started
_PendingCancel
_Completed
_Canceled

        {
            // Tracks the state of the task, rather than the task collection on which the task is scheduled
            _Created,
            _Started,
            _PendingCancel,
            _Completed,
            _Canceled
        };

Constructor & Destructor Documentation

Concurrency::details::_Task_impl_base::_Task_impl_base ( _CancellationTokenState *  _PTokenState, scheduler_ptr  _Scheduler_arg  )

inline

                          : _M_TaskState(_Created),
                            _M_fFromAsync(false), _M_fUnwrappedTask(false),
                            _M_pRegistration(nullptr), _M_Continuations(nullptr), _M_TaskCollection(_Scheduler_arg),
                            _M_taskEventLogger(this)
        {
            // Set cancellation token
            _M_pTokenState = _PTokenState;
            _ASSERTE(_M_pTokenState != nullptr);
            if (_M_pTokenState != _CancellationTokenState::_None())
                _M_pTokenState->_Reference();
        }

virtual Concurrency::details::_Task_impl_base::~_Task_impl_base ( )

inlinevirtual

        {
            _ASSERTE(_M_pTokenState != nullptr);
            if (_M_pTokenState != _CancellationTokenState::_None())
            {
                _M_pTokenState->_Release();
            }
        }

Concurrency::details::_Task_impl_base::_Task_impl_base ( const _Task_impl_base &  )

private

Member Function Documentation

template<typename _ReturnType , typename _InternalReturnType >

static void Concurrency::details::_Task_impl_base::_AsyncInit ( const typename _Task_ptr< _ReturnType >::_Type &  _OuterTask, const task< _InternalReturnType > &  _UnwrappedTask  )

inlinestatic

        {
            _ASSERTE(_OuterTask->_M_fUnwrappedTask && !_OuterTask->_IsCanceled());

            //
            // We must ensure that continuations off _OuterTask (especially exception handling ones) continue to function in the
            // presence of an exception flowing out of the inner task _UnwrappedTask. This requires an exception handling continuation
            // off the inner task which does the appropriate funnelling to the outer one. We use _Then instead of then to prevent
            // the exception from being marked as observed by our internal continuation. This continuation must be scheduled regardless
            // of whether or not the _OuterTask task is canceled.
            //
            _UnwrappedTask._Then([_OuterTask] (task<_InternalReturnType> _AncestorTask) {

                if (_AncestorTask._GetImpl()->_IsCompleted())
                {
                    _OuterTask->_FinalizeAndRunContinuations(_AncestorTask._GetImpl()->_GetResult());
                }
                else
                {
                    _ASSERTE(_AncestorTask._GetImpl()->_IsCanceled());
                    if (_AncestorTask._GetImpl()->_HasUserException())
                    {
                        // Set _PropagatedFromAncestor to false, since _AncestorTask is not an ancestor of _UnwrappedTask.
                        // Instead, it is the enclosing task.
                        _OuterTask->_CancelWithExceptionHolder(_AncestorTask._GetImpl()->_GetExceptionHolder(), false);
                    }
                    else
                    {
                        _OuterTask->_Cancel(true);
                    }
                }
            }, nullptr, details::_DefaultAutoInline);

        }

bool Concurrency::details::_Task_impl_base::_Cancel ( bool  _SynchronousCancel )

inline

        {
            // Send in a dummy value for exception. It is not used when the first parameter is false.
            return _CancelAndRunContinuations(_SynchronousCancel, false, false, _M_exceptionHolder);
        }

virtual bool Concurrency::details::_Task_impl_base::_CancelAndRunContinuations ( bool  _SynchronousCancel, bool  _UserException, bool  _PropagatedFromAncestor, const std::shared_ptr< _ExceptionHolder > &  _ExHolder  )

pure virtual

Requests cancellation on the task and schedules continuations if the task can be transitioned to a terminal state.

Parameters

_SynchronousCancel	Set to true if the cancel takes place as a result of the task body encountering an exception, or because an ancestor or task_completion_event the task was registered with were canceled with an exception. A synchronous cancel is one that assures the task could not be running on a different thread at the time the cancellation is in progress. An asynchronous cancel is one where the thread performing the cancel has no control over the thread that could be executing the task, that is the task could execute concurrently while the cancellation is in progress.
_UserException	Whether an exception other than the internal runtime cancellation exceptions caused this cancellation.
_PropagatedFromAncestor	Whether this exception came from an ancestor task or a task_completion_event as opposed to an exception that was encountered by the task itself. Only valid when _UserException is set to true.
_ExHolder	The exception holder that represents the exception. Only valid when _UserException is set to true.

Implemented in Concurrency::details::_Task_impl< _ReturnType >.

bool Concurrency::details::_Task_impl_base::_CancelWithException ( const std::exception_ptr &  _Exception )

inline

        {
            // This task was canceled because the task body encountered an exception.
            _ASSERTE(!_HasUserException());
            return _CancelAndRunContinuations(true, true, false, std::make_shared<_ExceptionHolder>(_Exception, _GetTaskCreationCallstack()));
        }

bool Concurrency::details::_Task_impl_base::_CancelWithExceptionHolder ( const std::shared_ptr< _ExceptionHolder > &  _ExHolder, bool  _PropagatedFromAncestor  )

inline

        {
            // This task was canceled because an ancestor task encountered an exception.
            return _CancelAndRunContinuations(true, true, _PropagatedFromAncestor, _ExHolder);
        }

void Concurrency::details::_Task_impl_base::_DeregisterCancellation ( )

inline

        {
            if (_M_pRegistration != nullptr)
            {
                _M_pTokenState->_DeregisterCallback(_M_pRegistration);
                _M_pRegistration->_Release();
                _M_pRegistration = nullptr;
            }
        }

const std::shared_ptr<_ExceptionHolder>& Concurrency::details::_Task_impl_base::_GetExceptionHolder ( )

inline

        {
            _ASSERTE(_HasUserException());
            return _M_exceptionHolder;
        }

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

inline

        {
            return _M_TaskCollection._GetScheduler();
        }

_TaskCreationCallstack Concurrency::details::_Task_impl_base::_GetTaskCreationCallstack ( )

inline

        {
            return _M_pTaskCreationCallstack;
        }

bool Concurrency::details::_Task_impl_base::_HasUserException ( )

inline

        {
            return static_cast<bool>(_M_exceptionHolder);
        }

bool Concurrency::details::_Task_impl_base::_IsApartmentAware ( )

inline

        {
            return _M_fFromAsync;
        }

bool Concurrency::details::_Task_impl_base::_IsCanceled ( )

inline

        {
            return (_M_TaskState == _Canceled);
        }

bool Concurrency::details::_Task_impl_base::_IsCompleted ( )

inline

        {
            return (_M_TaskState == _Completed);
        }

bool Concurrency::details::_Task_impl_base::_IsCreated ( )

inline

        {
            return (_M_TaskState == _Created);
        }

static _CRTIMP2 bool __cdecl Concurrency::details::_Task_impl_base::_IsNonBlockingThread ( )

static

bool Concurrency::details::_Task_impl_base::_IsPendingCancel ( )

inline

        {
            return (_M_TaskState == _PendingCancel);
        }

bool Concurrency::details::_Task_impl_base::_IsStarted ( )

inline

        {
            return (_M_TaskState == _Started);
        }

void Concurrency::details::_Task_impl_base::_RegisterCancellation ( std::weak_ptr< _Task_impl_base >  _WeakPtr )

inline

        {
            _ASSERTE(details::_CancellationTokenState::_IsValid(_M_pTokenState));

            auto _CancellationCallback = [_WeakPtr](){
                // Taking ownership of the task prevents dead lock during destruction
                // if the destructor waits for the cancellations to be finished
                auto _task = _WeakPtr.lock();
                if (_task != nullptr)
                    _task->_Cancel(false);
            };

            _M_pRegistration = new details::_CancellationTokenCallback<decltype(_CancellationCallback)>(_CancellationCallback);
            _M_pTokenState->_RegisterCallback(_M_pRegistration);
        }

void Concurrency::details::_Task_impl_base::_RunContinuation ( _ContinuationTaskHandleBase *  _PTaskHandle )

inline

Function executes a continuation. This function is recorded by a parent task implementation when a continuation is created in order to execute later.

Parameters

_PTaskHandle

The continuation task chore handle that need to be executed.

        {
            _Task_ptr_base _ImplBase = _PTaskHandle->_GetTaskImplBase();
            if (_IsCanceled() && !_PTaskHandle->_M_isTaskBasedContinuation)
            {
                if (_HasUserException())
                {
                    // If the ancestor encountered an exception, transfer the exception to the continuation
                    // This traverses down the tree to propagate the exception.
                    _ImplBase->_CancelWithExceptionHolder(_GetExceptionHolder(), true);
                }
                else
                {
                    // If the ancestor was canceled, then your own execution should be canceled.
                    // This traverses down the tree to cancel it.
                    _ImplBase->_Cancel(true);
                }
            }
            else
            {
                // This can only run when the ancestor has completed or it's a task based continuation that fires when a task is canceled
                // (with or without a user exception).
                _ASSERTE(_IsCompleted() || _PTaskHandle->_M_isTaskBasedContinuation);
                _ASSERTE(!_ImplBase->_IsCanceled());
                return _ImplBase->_ScheduleContinuationTask(_PTaskHandle);
            }

            // If the handle is not scheduled, we need to manually delete it.
            delete _PTaskHandle;
        }

void Concurrency::details::_Task_impl_base::_RunTaskContinuations ( )

inline

        {
            // The link list can no longer be modified at this point,
            // since all following up continuations will be scheduled by themselves.
            _ContinuationList _Cur = _M_Continuations, _Next;
            _M_Continuations = nullptr;
            while (_Cur)
            {
                // Current node might be deleted after running,
                // so we must fetch the next first.
                _Next = _Cur->_M_next;
                _RunContinuation(_Cur);
                _Cur = _Next;
            }
        }

void Concurrency::details::_Task_impl_base::_ScheduleContinuation ( _ContinuationTaskHandleBase *  _PTaskHandle )

inline

Schedule the actual continuation. This will either schedule the function on the continuation task's implementation if the task has completed or append it to a list of functions to execute when the task actually does complete.

Template Parameters

_FuncInputType	The input type of the task.
_FuncOutputType	The output type of the task.

        {
            enum { _Nothing, _Schedule, _Cancel, _CancelWithException } _Do = _Nothing;

            // If the task has canceled, cancel the continuation. If the task has completed, execute the continuation right away.
            // Otherwise, add it to the list of pending continuations
            {
                ::std::lock_guard<std::mutex> _LockHolder(_M_ContinuationsCritSec);
                if (_IsCompleted() || (_IsCanceled() && _PTaskHandle->_M_isTaskBasedContinuation))
                {
                    _Do = _Schedule;
                }
                else if (_IsCanceled())
                {
                    if (_HasUserException())
                    {
                        _Do = _CancelWithException;
                    }
                    else
                    {
                        _Do = _Cancel;
                    }
                }
                else
                {
                    // chain itself on the continuation chain.
                    _PTaskHandle->_M_next = _M_Continuations;
                    _M_Continuations = _PTaskHandle;
                }
            }

            // Cancellation and execution of continuations should be performed after releasing the lock. Continuations off of
            // async tasks may execute inline.
            switch (_Do)
            {
                case _Schedule:
                {
                    _PTaskHandle->_GetTaskImplBase()->_ScheduleContinuationTask(_PTaskHandle);
                    break;
                }
                case _Cancel:
                {
                    // If the ancestor was canceled, then your own execution should be canceled.
                    // This traverses down the tree to cancel it.
                    _PTaskHandle->_GetTaskImplBase()->_Cancel(true);

                    delete _PTaskHandle;
                    break;
                }
                case _CancelWithException:
                {
                    // If the ancestor encountered an exception, transfer the exception to the continuation
                    // This traverses down the tree to propagate the exception.
                    _PTaskHandle->_GetTaskImplBase()->_CancelWithExceptionHolder(_GetExceptionHolder(), true);

                    delete _PTaskHandle;
                    break;
                }
                case _Nothing:
                default:
                    // In this case, we have inserted continuation to continuation chain,
                    // nothing more need to be done, just leave.
                    break;
            }
        }

void Concurrency::details::_Task_impl_base::_ScheduleContinuationTask ( _ContinuationTaskHandleBase *  _PTaskHandle )

inline

        {

            _M_taskEventLogger._LogScheduleTask(true);
            // Ensure that the continuation runs in proper context (this might be on a Concurrency Runtime thread or in a different Windows Runtime apartment)
            if (_PTaskHandle->_M_continuationContext._HasCapturedContext())
            {
                // For those continuations need to be scheduled inside captured context, we will try to apply automatic inlining to their inline modes,
                // if they haven't been specified as _ForceInline yet. This change will encourage those continuations to be executed inline so that reduce
                // the cost of marshaling.
                // For normal continuations we won't do any change here, and their inline policies are completely decided by ._ThenImpl method.
                if (_PTaskHandle->_M_inliningMode != details::_ForceInline)
                {
                    _PTaskHandle->_M_inliningMode = details::_DefaultAutoInline;
                }
                _ScheduleFuncWithAutoInline([_PTaskHandle]() {
                    // Note that we cannot directly capture "this" pointer, instead, we should use _TaskImplPtr, a shared_ptr to the _Task_impl_base.
                    // Because "this" pointer will be invalid as soon as _PTaskHandle get deleted. _PTaskHandle will be deleted after being scheduled.
                    auto _TaskImplPtr = _PTaskHandle->_GetTaskImplBase();
                    if (details::_ContextCallback::_CaptureCurrent() == _PTaskHandle->_M_continuationContext)
                    {
                        _TaskImplPtr->_ScheduleTask(_PTaskHandle, details::_ForceInline);
                    }
                    else
                    {
                        //
                        // It's entirely possible that the attempt to marshal the call into a differing context will fail. In this case, we need to handle
                        // the exception and mark the continuation as canceled with the appropriate exception. There is one slight hitch to this:
                        //
                        // NOTE: COM's legacy behavior is to swallow SEH exceptions and marshal them back as HRESULTS. This will in effect turn an SEH into
                        // a C++ exception that gets tagged on the task. One unfortunate result of this is that various pieces of the task infrastructure will
                        // not be in a valid state after this in /EHsc (due to the lack of destructors running, etc...).
                        //
                        _TRY_BEGIN
                        _PTaskHandle->_M_continuationContext._CallInContext( [_PTaskHandle, _TaskImplPtr](){
                            _TaskImplPtr->_ScheduleTask(_PTaskHandle, details::_ForceInline);
                        });
                        _CATCH_ALL
                        _TaskImplPtr->_CancelWithException(std::current_exception());
                        _CATCH_END
                    }
                }, _PTaskHandle->_M_inliningMode);
            }
            else
            {
                _ScheduleTask(_PTaskHandle, _PTaskHandle->_M_inliningMode);
            }
        }

void Concurrency::details::_Task_impl_base::_ScheduleTask ( _UnrealizedChore_t *  _PTaskHandle, _TaskInliningMode_t  _InliningMode  )

inline

Helper function to schedule the task on the Task Collection.

Parameters

_PTaskHandle	The task chore handle that need to be executed.
_InliningMode	The inlining scheduling policy for current _PTaskHandle.

        {
            _TRY_BEGIN
            _M_TaskCollection._ScheduleTask(_PTaskHandle, _InliningMode);
            _CATCH(const task_canceled &)
            // task_canceled is a special exception thrown by cancel_current_task. The spec states that cancel_current_task
            // must be called from code that is executed within the task (throwing it from parallel work created by and waited
            // upon by the task is acceptable). We can safely assume that the task wrapper _PPLTaskHandle::operator() has seen
            // the exception and canceled the task. Swallow the exception here.
            _ASSERTE(_IsCanceled());
            _CATCH(const _Interruption_exception &)
            // The _TaskCollection will never be an interruption point since it has a none token.
            _ASSERTE(false);
            _CATCH_ALL
            // The exception could have come from two places:
            //   1. From the chore body, so it already should have been caught and canceled.
            //      In this case swallow the exception.
            //   2. From trying to actually schedule the task on the scheduler.
            //      In this case cancel the task with the current exception, otherwise the
            //      task will never be signaled leading to deadlock when waiting on the task.

            if (!_HasUserException())
            {
                _CancelWithException(std::current_exception());
            }
            _CATCH_END
        }

void Concurrency::details::_Task_impl_base::_SetAsync ( bool  _Async = true )

inline

        {
            _M_fFromAsync = _Async;
        }

void Concurrency::details::_Task_impl_base::_SetTaskCreationCallstack ( const _TaskCreationCallstack &  _Callstack )

inline

        {
            _M_pTaskCreationCallstack = _Callstack;
        }

task_status Concurrency::details::_Task_impl_base::_Wait ( )

inline

        {
            bool _DoWait = true;

            if (_IsNonBlockingThread())
            {
                // In order to prevent Windows Runtime STA threads from blocking the UI, calling task.wait() task.get() is illegal
                // if task has not been completed.
                if (!_IsCompleted() && !_IsCanceled())
                {
                    _THROW_NCEE(invalid_operation, "Illegal to wait on a task in a Windows Runtime STA");
                }
                else
                {
                    // Task Continuations are 'scheduled' *inside* the chore that is executing on the ancestor's task group. If a continuation
                    // needs to be marshalled to a different apartment instead of scheduling, we make a synchronous cross-apartment COM
                    // call to execute the continuation. If it then happens to do something which waits on the ancestor (say it calls .get(),
                    // which task based continuations are wont to do), waiting on the task group results in waiting on the chore that is making
                    // this synchronous callback, which causes a deadlock. To avoid this, we test the state of the ancestor's event,
                    // and we will NOT wait on it if it has finished execution (which means now we are in the inline synchronous callback).
                    _DoWait = false;
                }
            }

            if (_DoWait)
            {
                // If this task was created from a Windows Runtime async operation, do not attempt to inline it. The
                // async operation will take place on a thread in the appropriate apartment Simply wait for the completed
                // event to be set.
                if (_M_fFromAsync)
                {
                    _M_TaskCollection._Wait();
                }
                else
                {
                    // Wait on the task collection to complete. The task collection is guaranteed to still be
                    // valid since the task must be still within scope so that the _Task_impl_base destructor
                    // has not yet been called. This call to _Wait potentially inlines execution of work.
                    _TRY_BEGIN
                    // Invoking wait on a task collection resets the state of the task collection. This means that
                    // if the task collection itself were canceled, or had encountered an exception, only the first
                    // call to wait will receive this status. However, both cancellation and exceptions flowing through
                    // tasks set state in the task impl itself.

                    // 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_TaskCollection._RunAndWait();
                    _CATCH(details::_Interruption_exception&)
                    // The _TaskCollection will never be an interruption point since it has a none token.
                    _ASSERTE(false);
                    _CATCH(task_canceled&)
                    // task_canceled is a special exception thrown by cancel_current_task. The spec states that cancel_current_task
                    // must be called from code that is executed within the task (throwing it from parallel work created by and waited
                    // upon by the task is acceptable). We can safely assume that the task wrapper _PPLTaskHandle::operator() has seen
                    // the exception and canceled the task. Swallow the exception here.
                    _ASSERTE(_IsCanceled());
                    _CATCH_ALL
                    // It's possible the task body hasn't seen the exception; if so we need to cancel with exception here.
                    if(!_HasUserException())
                    {
                        _CancelWithException(std::current_exception());
                    }
                    // Rethrow will mark the exception as observed.
                    _M_exceptionHolder->_RethrowUserException();
                    _CATCH_END

                    // If the lambda body for this task (executed or waited upon in _RunAndWait above) happened to return a task
                    // which is to be unwrapped and plumbed to the output of this task, we must not only wait on the lambda body, we must
                    // wait on the **INNER** body. It is in theory possible that we could inline such if we plumb a series of things through;
                    // however, this takes the tact of simply waiting upon the completion signal.
                    if (_M_fUnwrappedTask)
                    {
                        _M_TaskCollection._Wait();
                    }
                }
            }

            if (_HasUserException())
            {
                _M_exceptionHolder->_RethrowUserException();
            }
            else if (_IsCanceled())
            {
                return canceled;
            }
            _ASSERTE(_IsCompleted());
            return completed;
        }

_Task_impl_base const& Concurrency::details::_Task_impl_base::operator= ( _Task_impl_base const &  )

private

Member Data Documentation

_ContinuationList Concurrency::details::_Task_impl_base::_M_Continuations

std::mutex Concurrency::details::_Task_impl_base::_M_ContinuationsCritSec

std::shared_ptr<_ExceptionHolder> Concurrency::details::_Task_impl_base::_M_exceptionHolder

bool Concurrency::details::_Task_impl_base::_M_fFromAsync

bool Concurrency::details::_Task_impl_base::_M_fUnwrappedTask

_CancellationTokenRegistration* Concurrency::details::_Task_impl_base::_M_pRegistration

_TaskCreationCallstack Concurrency::details::_Task_impl_base::_M_pTaskCreationCallstack

_CancellationTokenState* Concurrency::details::_Task_impl_base::_M_pTokenState

::Concurrency::details::_TaskCollection_t Concurrency::details::_Task_impl_base::_M_TaskCollection

_TaskEventLogger Concurrency::details::_Task_impl_base::_M_taskEventLogger

volatile _TaskInternalState Concurrency::details::_Task_impl_base::_M_TaskState

---

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

• VS2015/inc/ppltasks.h