Concurrency::details::_SpinWait< _YieldCount > Class Template Reference

Implements busy wait with no backoff More...

#include <concrt.h>

Public Types
typedef void(__cdecl *	_YieldFunction) ()

Public Member Functions
	_SpinWait (_YieldFunction _YieldMethod=_UnderlyingYield)
	Construct a spin wait object More...
void	_SetSpinCount (unsigned int _Count)
	Set a dynamic spin count. More...
bool	_SpinOnce ()
	Spins for one time quantum,until a maximum spin is reached. More...

Protected Types
enum	_SpinState {   _StateInitial, _StateSpin, _StateYield, _StateBlock,   _StateSingle }
	State of the spin wait class. More...

Protected Member Functions
void	_DoYield ()
	Yields its time slice using the specified yieldFunction More...
void	_Reset ()
	Resets the counts and state to the default. More...
unsigned long	_NumberOfSpins ()
	Determines the current spin count More...
bool	_ShouldSpinAgain ()
	Determines whether maximum spin has been reached More...

Protected Attributes
unsigned long	_M_currentSpin
unsigned long	_M_currentYield
_SpinState	_M_state
_YieldFunction	_M_yieldFunction

Detailed Description

template<unsigned int _YieldCount = 1>
class Concurrency::details::_SpinWait< _YieldCount >

Implements busy wait with no backoff

Member Typedef Documentation

template<unsigned int _YieldCount = 1>

typedef void(__cdecl * Concurrency::details::_SpinWait< _YieldCount >::_YieldFunction) ()

Member Enumeration Documentation

template<unsigned int _YieldCount = 1>

enum Concurrency::details::_SpinWait::_SpinState

protected

State of the spin wait class.

Enumerator
_StateInitial
_StateSpin
_StateYield
_StateBlock
_StateSingle

        {
            _StateInitial,
            _StateSpin,
            _StateYield,
            _StateBlock,
            _StateSingle
        };

Constructor & Destructor Documentation

template<unsigned int _YieldCount = 1>

Concurrency::details::_SpinWait< _YieldCount >::_SpinWait ( _YieldFunction  _YieldMethod = _UnderlyingYield )

inline

Construct a spin wait object

            : _M_yieldFunction(_YieldMethod), _M_state(_StateInitial)
        {
            // Defer initialization of other fields to _SpinOnce().
        }

Member Function Documentation

template<unsigned int _YieldCount = 1>

void Concurrency::details::_SpinWait< _YieldCount >::_DoYield ( )

inlineprotected

Yields its time slice using the specified yieldFunction

        {
#pragma warning ( push )
#pragma warning ( disable : 6326 )  // potential comparison of a constant with another constant
            bool _ShouldYield = (_YieldCount != 0);
#pragma warning ( pop )
            if (_ShouldYield)
            {
                _CONCRT_ASSERT(_M_yieldFunction != NULL);
                _M_yieldFunction();
            }
            else
            {
                _YieldProcessor();
            }
        }

template<unsigned int _YieldCount = 1>

unsigned long Concurrency::details::_SpinWait< _YieldCount >::_NumberOfSpins ( )

inlineprotected

Determines the current spin count

Returns

The number of spins to execute for this iteration

        {
            return 1;
        }

template<unsigned int _YieldCount = 1>

void Concurrency::details::_SpinWait< _YieldCount >::_Reset ( )

inlineprotected

Resets the counts and state to the default.

        {
            _M_state = _StateInitial;

            // Reset to the default spin value. The value specified
            // by the client is ignored on a reset.
            _SetSpinCount(_SpinCount::_Value());

            _CONCRT_ASSERT(_M_state != _StateInitial);
        }

template<unsigned int _YieldCount = 1>

void Concurrency::details::_SpinWait< _YieldCount >::_SetSpinCount ( unsigned int  _Count )

inline

Set a dynamic spin count.

        {
            _CONCRT_ASSERT(_M_state == _StateInitial);
            if (_Count == 0)
            {
                // Specify a count of 0 if we are on a single proc.
                _M_state = _StateSingle;
            }
            else
            {
                _M_currentSpin = _Count;
                _M_currentYield = _YieldCount;
                _M_state = _StateSpin;
            }
        }

template<unsigned int _YieldCount = 1>

bool Concurrency::details::_SpinWait< _YieldCount >::_ShouldSpinAgain ( )

inlineprotected

Determines whether maximum spin has been reached

Returns

false if spin count has reached steady state, true otherwise.

        {
            return (--_M_currentSpin > 0);
        }

template<unsigned int _YieldCount = 1>

bool Concurrency::details::_SpinWait< _YieldCount >::_SpinOnce ( )

inline

Spins for one time quantum,until a maximum spin is reached.

Returns

false if spin count has reached steady state, true otherwise.

If the spin count is not changing do not spin again because there is either only one processor, or the maximum spin has been reached and blocking is probably a better solution. However, if called again, SpinOnce will spin for a maximum spin count.

        {
            switch (_M_state)
            {
            case _StateSpin:
            {
                unsigned long _Count = _NumberOfSpins();

                for (unsigned long _I = 0; _I < _Count; _I++)
                {
                    _YieldProcessor();
                }

                if (!_ShouldSpinAgain())
                {
                    _M_state = (_M_currentYield == 0) ? _StateBlock : _StateYield;
                }

                return true;
            }

            case _StateYield:
                _CONCRT_ASSERT(_M_currentYield > 0);
                if (--_M_currentYield == 0)
                {
                    _M_state = _StateBlock;
                }

                // Execute the yield
                _DoYield();
                return true;

            case _StateBlock:
                // Reset to defaults if client does not block
                _Reset();
                return false;

            case _StateSingle:
                // No need to spin on a single processor: just execute the yield
                _DoYield();
                return false;

            case _StateInitial:
                // Reset counters to their default value and Spin once.
                _Reset();
                return _SpinOnce();
            default:
                // Unreached
                return false;
            };
        }

Member Data Documentation

template<unsigned int _YieldCount = 1>

unsigned long Concurrency::details::_SpinWait< _YieldCount >::_M_currentSpin

protected

template<unsigned int _YieldCount = 1>

unsigned long Concurrency::details::_SpinWait< _YieldCount >::_M_currentYield

protected

template<unsigned int _YieldCount = 1>

_SpinState Concurrency::details::_SpinWait< _YieldCount >::_M_state

protected

template<unsigned int _YieldCount = 1>

_YieldFunction Concurrency::details::_SpinWait< _YieldCount >::_M_yieldFunction

protected

---

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

• VS2015/inc/concrt.h