Add files using upload-large-folder tool

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Agent.cpp

@@ -0,0 +1,426 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Agent.cpp
+//
+// Source file containing code for the agent creation APIs.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+#include <agents.h>
+
+namespace Concurrency
+{
+
+// A Filter function for a filter_block to check if the Agent has completed
+bool _IsDone(agent_status const &status)
+{
+    return status == agent_done || status == agent_canceled;
+}
+
+// A Filter function for a filter_block to check if the Agent has started (or completed)
+bool _IsStarted(agent_status const &status)
+{
+    return _IsDone(status) || status == agent_started;
+}
+
+/// <summary>
+///     Creates an agent within the default scheduler, and places it any schedule
+///     group of the scheduler's choosing.
+/// </summary>
+agent::agent() :
+    _M_fStartable(TRUE), _M_fCancelable(TRUE), _M_pScheduler(NULL), _M_pScheduleGroup(NULL)
+{
+    _Trace_agents(AGENTS_EVENT_CREATE,
+        details::_Trace_agents_get_id(this),
+        details::_Trace_agents_get_id(this));
+
+    send<agent_status> (_M_status, agent_created);
+}
+
+/// <summary>
+///     Create an agent within the specified scheduler, in a schedule group of the
+///     scheduler's choosing.
+/// </summary>
+agent::agent(Scheduler& pScheduler) :
+    _M_fStartable(TRUE), _M_fCancelable(TRUE), _M_pScheduler(&pScheduler), _M_pScheduleGroup(NULL)
+{
+    _Trace_agents(AGENTS_EVENT_CREATE,
+        details::_Trace_agents_get_id(this),
+        details::_Trace_agents_get_id(this));
+
+    send<agent_status> (_M_status, agent_created);
+}
+
+/// <summary>
+///     Create an agent within the specified schedule group.  The scheduler is implied
+///     by the schedule group.
+/// </summary>
+agent::agent(ScheduleGroup& pGroup) :
+    _M_fStartable(TRUE), _M_fCancelable(TRUE), _M_pScheduler(NULL), _M_pScheduleGroup(&pGroup)
+{
+    _Trace_agents(AGENTS_EVENT_CREATE,
+        details::_Trace_agents_get_id(this),
+        details::_Trace_agents_get_id(this));
+
+    send<agent_status> (_M_status, agent_created);
+}
+
+/// <summary>
+///     Cleans up any resources that may have been created by the Agent.
+/// </summary>
+agent::~agent()
+{
+    _Trace_agents(AGENTS_EVENT_DESTROY, details::_Trace_agents_get_id(this));
+}
+
+/// <returns>
+///     Returns a message source that can pass messages about the current state of the agent
+/// </returns>
+ISource<agent_status> * agent::status_port()
+{
+    return &_M_status;
+}
+
+/// <returns>
+///     Returns the current state of the agent.  Note that this returned state could change
+///     immediately after being returned.
+/// </returns>
+agent_status agent::status()
+{
+    return receive<agent_status>(_M_status);
+}
+
+/// <summary>
+///     Moves an Agent from the agent_created state to the agent_runnable state, and schedules it for execution.
+/// </summary>
+/// <returns>
+///     true if the agent started correctly, false otherwise
+/// </returns>
+bool agent::start()
+{
+    if(_M_status.value() != agent_created)
+    {
+        return false;
+    }
+
+    //
+    // Check if the agent is Startable.  If the agent had already called start() or
+    // this variable was set to FALSE in cancel(), return false.
+    //
+    if(InterlockedCompareExchange(&_M_fStartable, FALSE, TRUE) == FALSE)
+    {
+        return false;
+    }
+
+    _Trace_agents(AGENTS_EVENT_SCHEDULE, details::_Trace_agents_get_id(this));
+    send<agent_status> (_M_status, agent_runnable);
+
+    TaskProc proc = &Concurrency::agent::_Agent_task_wrapper;
+    if(_M_pScheduleGroup != NULL)
+    {
+        _M_pScheduleGroup->ScheduleTask(proc, this);
+    }
+    else if(_M_pScheduler != NULL)
+    {
+        _M_pScheduler->ScheduleTask(proc, this);
+    }
+    else
+    {
+        CurrentScheduler::ScheduleTask(proc, this);
+    }
+
+    return true;
+}
+
+/// <summary>
+///     Moves an agent into the done state, indicating the completion of the agent
+/// </summary>
+/// <returns>
+///     true if the agent is moved to the agent_done state, false otherwise
+/// </returns>
+bool agent::done()
+{
+    //
+    // current status
+    //
+    agent_status currentStatus = this->status();
+
+    //
+    // Indicate that the agent can no longer be started.
+    //
+    if (InterlockedCompareExchange(&_M_fStartable, FALSE, TRUE) != TRUE)
+    {
+        //
+        // agent is either canceled, started or completed run.
+        //
+        currentStatus = receive<agent_status>(_M_status, _IsStarted);
+    }
+
+    //
+    // Agent is not cancelable anymore.
+    //
+    InterlockedExchange(&_M_fCancelable, FALSE);
+
+    //
+    // Transition to agent_done state if it not already in one of
+    // the terminal states.
+    //
+    if ((currentStatus != agent_canceled) && (currentStatus != agent_done))
+    {
+        send<agent_status> (_M_status, agent_done);
+
+        return true;
+    }
+
+    return false;
+}
+
+/// <summary>
+///     Moves an agent from the agent_created or agent_runnable to the agent_canceled state.
+/// </summary>
+/// <returns>
+///     true if the agent was canceled correctly, false otherwise
+/// </returns>
+bool agent::cancel()
+{
+    //
+    // In case this agent has been canceled before it was even started
+    // mark it as no longer Startable and send a agent_canceled message to the
+    // status port
+    //
+    if(InterlockedCompareExchange(&_M_fStartable, FALSE, TRUE) == TRUE)
+    {
+        send<agent_status> (_M_status, agent_canceled);
+    }
+
+    //
+    // Check to see if the agent is still Cancelable.  Agents are initialized
+    // m_fCancelable == TRUE, and set to false either here in cancel(), so
+    // cancel() will not be called twice, or in the LWT, once the execution
+    // of the Agent task has begun.
+    //
+    if(InterlockedCompareExchange(&_M_fCancelable, FALSE, TRUE) == TRUE)
+    {
+        // Wait for the agent to reach a canceled state state
+        receive<agent_status>(_M_status, _IsDone);
+
+        // The above InterlockedCompareExchange marked this agent for cancellation
+        // When the LWT that has been spun up tries to execute the task, it will
+        // find it has been canceled and will propagate out the canceled state to
+        // the state buffer.
+        return true;
+    }
+
+    return false;
+}
+
+
+// Private helper class to order an input array of agents. This is used by
+// wait_for_all and wait_for_one to create an array of appropriate order nodes.
+// The template _OrderNode specifies an _Order_node_base that accepts agent_status.
+// For example, _Reserving_node<agent_status>
+template<class _OrderNode>
+class _OrderBlock
+{
+public:
+
+    // Constructs an orderBlock which has an array of ordernodes connected to the agents.
+    // The ordernodes are given a filter method to filter out non-terminal agent states
+    _OrderBlock(size_t _Count, agent ** _PAgents, ITarget<size_t> * _PTarget) : _M_count(_Count)
+    {
+        // Create an array of order nodes
+        _M_ppNodes = _concrt_new _OrderNode*[_M_count];
+        for (size_t i = 0; i < _M_count; i++)
+        {
+            _M_ppNodes[i] = _concrt_new _OrderNode(_PAgents[i]->status_port(), i, _PTarget, _IsDone);
+        }
+    }
+
+    // Destroys the block
+    ~_OrderBlock()
+    {
+        for (size_t i = 0; i < _M_count; i++)
+        {
+            delete _M_ppNodes[i];
+        }
+
+        delete [] _M_ppNodes;
+    }
+
+    // Retrieve the agent status for the agent at the given index
+    agent_status _Status(size_t _Index)
+    {
+        _CONCRT_ASSERT(_M_ppNodes[_Index]->has_value());
+
+        return _M_ppNodes[_Index]->value();
+    }
+
+private:
+
+    // Number of order nodes
+    size_t _M_count;
+
+    // Array of order nodes
+    _OrderNode ** _M_ppNodes;
+};
+
+
+/// <summary>
+///     Wait for an agent to complete its task. A task is completed when it enters the agent_canceled,
+///     or agent_done states.
+/// </summary>
+agent_status agent::wait(_Inout_ agent * pAgent, unsigned int timeout)
+{
+    if(pAgent == NULL)
+    {
+        throw std::invalid_argument("pAgent");
+    }
+
+    return receive<agent_status>(pAgent->status_port(), _IsDone, timeout);
+}
+
+/// <summary>
+/// Wait for all agents in a given Agent array to complete their tasks. A task is completed
+/// when it enters the agent_canceled or agent_done states.
+/// </summary>
+void agent::wait_for_all(size_t count, _In_reads_(count) agent ** pAgents, _Out_writes_opt_(count) agent_status * pStatus, unsigned int timeout)
+{
+    if ( pAgents == NULL )
+    {
+        throw std::invalid_argument("pAgents");
+    }
+
+    for (size_t i = 0; i < count; i++)
+    {
+        if ( pAgents[i] == NULL )
+        {
+            throw std::invalid_argument("pAgents");
+        }
+    }
+
+    // Create the following network
+    //
+    //  agent - orderNode -
+    //                     \
+    //  agent - orderNode - --call ~~~ single_assignment
+    //                     /
+    //  agent - orderNode -
+
+    single_assignment<size_t> _Sa;
+    volatile size_t _CompletedAgents = 0;
+    call<size_t> _Call([&](size_t const&)
+    {
+        // Safe to access without synchronization since call blocks
+        // guarantee that the function is not called for multiple
+        // messages at the same time.
+        _CONCRT_ASSERT(_CompletedAgents < count);
+        size_t value = _CompletedAgents;
+        _CompletedAgents = ++value;
+        if (_CompletedAgents == count)
+        {
+            // All the agents have completed. Indicate the same by sending a message
+            // (initialize) to the single assignment.
+            send<size_t>(_Sa, 1);
+        }
+    });
+
+    _OrderBlock<_Greedy_node<agent_status>>  _OrderedAgents(count, pAgents, &_Call);
+
+    receive(&_Sa, timeout);
+
+    // single_assignment has a message => all agents completed
+    // Retrieve their status messages.
+    if(pStatus != NULL)
+    {
+        for (size_t i = 0; i < count; i++)
+        {
+            pStatus[i] = _OrderedAgents._Status(i);
+        }
+    }
+}
+
+/// <summary>
+///     Wait for any one of the agents in a given AgentTask array to complete its task. A task is completed
+///     when it enters the agent_canceled or agent_done states.
+/// </summary>
+void agent::wait_for_one(size_t count, _In_reads_(count) agent ** pAgents, agent_status &status, size_t& index, unsigned int timeout)
+{
+    if ( pAgents == NULL )
+    {
+        throw std::invalid_argument("pAgents");
+    }
+
+    for (size_t i = 0; i < count; i++)
+    {
+        if ( pAgents[i] == NULL )
+        {
+            throw std::invalid_argument("pAgents");
+        }
+    }
+
+    // Create the following network
+    //
+    //  agent - orderNode -
+    //                     \
+    //  agent - orderNode - --single_assignment
+    //                     /
+    //  agent - orderNode -
+
+    single_assignment<size_t> _Sa;
+    _OrderBlock<_Greedy_node<agent_status>>  _OrderedAgents(count, pAgents, &_Sa);
+
+    index = receive(&_Sa, timeout);
+
+    // We were able to receive the index. Get the message (agent_status)
+    status = _OrderedAgents._Status(index);
+}
+
+// A static wrapper function that calls the Run() method.  Used for scheduling of the task
+void agent::_Agent_task_wrapper(void* data)
+{
+    agent *pAgent = (agent *) data;
+
+    if(InterlockedCompareExchange(&pAgent->_M_fCancelable, FALSE, TRUE) == TRUE)
+    {
+        send<agent_status> (pAgent->_M_status, agent_started);
+
+        // Invoke the run() function of the agent.
+        _Trace_agents(AGENTS_EVENT_START, details::_Trace_agents_get_id(pAgent));
+        pAgent->run();
+        _Trace_agents(AGENTS_EVENT_END, details::_Trace_agents_get_id(pAgent), 0);
+    }
+    else
+    {
+        // This else path can be entered only if an agent was canceled before it
+        // ran.  Send a agent_canceled message to the status.
+        send<agent_status> (pAgent->_M_status, agent_canceled);
+    }
+}
+
+// Implementation of agent APIs that should not be publicly exposed
+
+namespace details
+{
+    static volatile runtime_object_identity s_RuntimeObjectIdentity = 0;
+
+    _CONCRTIMP _Runtime_object::_Runtime_object()
+    {
+        // Increment the id by 2.  This is done because certain blocks (like join) need to have
+        // a special message id to indicate a NULL id.  In this case, we use -1.  Incrementing by 2
+        // will avoid any wrap-around issues causing us to hit -1.
+        runtime_object_identity id = InterlockedExchangeAdd((volatile long *) &s_RuntimeObjectIdentity, 2);
+        _CONCRT_ASSERT(id != -1);
+        _M_id = id;
+    }
+
+    _CONCRTIMP _Runtime_object::_Runtime_object(runtime_object_identity _Id) : _M_id(_Id)
+    {
+    }
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/CacheLocalScheduleGroup.cpp

@@ -0,0 +1,99 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// CacheLocalScheduleGroup.cpp
+//
+// Implementation file for CacheLocalScheduleGroup.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Puts a runnable context into the runnables collection in the schedule group.
+    /// </summary>
+    void CacheLocalScheduleGroupSegment::AddToRunnablesCollection(InternalContextBase* pContext)
+    {
+        m_runnableContexts.Enqueue(pContext);
+    }
+
+    /// <summary>
+    ///     Places a chore in the mailbox associated with this schedule group segment.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to mail.
+    /// </param>
+    /// <returns>
+    ///     The mailbox slot into which the chore was placed.
+    /// </returns>
+    /// <remarks>
+    ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+    ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+    /// </remarks>
+    Mailbox<_UnrealizedChore>::Slot CacheLocalScheduleGroupSegment::MailChore(_UnrealizedChore *pChore)
+    {
+        //
+        // There are two possible segments to which pChore can be accounted.  One is the segment where it will appear on the WSQ -- the other is
+        // the segment where it will appear on the mailbox.  Both are in the same group and hence we do not at present have reference counting
+        // issues.  It will be attributed to the group it was picked up from which will further honor that affinity if the task blocks, etc...
+        //
+        ASSERT(!m_affinity._Is_system());
+        Mailbox<_UnrealizedChore>::Slot affinitySlot = m_mailedTasks.Enqueue(pChore);
+
+        ASSERT(!affinitySlot.IsEmpty());
+        return affinitySlot;
+    }
+
+    /// <summary>
+    ///     Notifies virtual processors that work affinitized to them has become available in the schedule group segment.
+    /// </summary>
+    void CacheLocalScheduleGroupSegment::NotifyAffinitizedWork()
+    {
+        SchedulerBase *pScheduler = m_pOwningGroup->GetScheduler();
+        pScheduler->PostAffinityMessage(m_affinitySet);
+
+        //
+        // If this item qualifies for the quick cache, stash it.
+        //
+        if (m_affinity._GetType() == location::_ExecutionResource)
+        {
+            pScheduler->SetQuickCacheSlot(m_maskIdIf, this);
+        }
+    }
+
+    /// <summary>
+    ///     Places a chore in a mailbox associated with the schedule group which is biased towards tasks being picked up from the specified
+    ///     location.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to mail.
+    /// </param>
+    /// <param name="pPlacement">
+    ///     A pointer to a location where the chore will be mailed.
+    /// </param>
+    /// <returns>
+    ///     The mailbox slot into which the chore was placed.
+    /// </returns>
+    /// <remarks>
+    ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+    ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+    /// </remarks>
+    Mailbox<_UnrealizedChore>::Slot CacheLocalScheduleGroup::MailChore(_UnrealizedChore * pChore,
+                                                                       location * pPlacement,
+                                                                       ScheduleGroupSegmentBase ** ppDestinationSegment)
+    {
+        CacheLocalScheduleGroupSegment * pCacheLocalSegment = static_cast<CacheLocalScheduleGroupSegment *>(LocateSegment(pPlacement, true));
+        *ppDestinationSegment = pCacheLocalSegment;
+        return pCacheLocalSegment->MailChore(pChore);
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/CacheLocalScheduleGroup.h

@@ -0,0 +1,159 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// CacheLocalScheduleGroup.h
+//
+// Header file containing CacheLocalScheduleGroup related declarations.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+
+    class CacheLocalScheduleGroup;
+
+    class CacheLocalScheduleGroupSegment : public ScheduleGroupSegmentBase
+    {
+
+    public:
+
+        //
+        // Public Methods
+        //
+
+        /// <summary>
+        ///     Constructs a cache local schedule group segment
+        /// </summary>
+        CacheLocalScheduleGroupSegment(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location* pSegmentAffinity) :
+            ScheduleGroupSegmentBase(pOwningGroup, pOwningRing, pSegmentAffinity)
+        {
+        }
+
+        /// <summary>
+        ///     Places a chore in the mailbox associated with this schedule group segment.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to mail.
+        /// </param>
+        /// <returns>
+        ///     The mailbox slot into which the chore was placed.
+        /// </returns>
+        /// <remarks>
+        ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+        ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+        /// </remarks>
+        Mailbox<_UnrealizedChore>::Slot MailChore(_UnrealizedChore *pChore);
+
+        /// <summary>
+        ///     Notifies virtual processors that work affinitized to them has become available in the schedule group segment.
+        /// </summary>
+        virtual void NotifyAffinitizedWork();
+
+    protected:
+
+
+    private:
+        friend class SchedulerBase;
+        friend class CacheLocalScheduleGroup;
+        friend class ContextBase;
+        friend class ExternalContextBase;
+        friend class InternalContextBase;
+        friend class ThreadInternalContext;
+        friend class SchedulingNode;
+        friend class SchedulingRing;
+        friend class VirtualProcessor;
+
+        //
+        // Private data
+        //
+
+        // Each schedule group has three stores of work. It has a collection of runnable contexts,
+        // a FIFO queue of realized chores and a list of workqueues that hold unrealized chores.
+
+        // A collection of Runnable contexts.
+        SafeSQueue<InternalContextBase, _HyperNonReentrantLock> m_runnableContexts;
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Puts a runnable context into the runnables collection in the schedule group.
+        /// </summary>
+        void AddToRunnablesCollection(InternalContextBase *pContext);
+
+        InternalContextBase *GetRunnableContext()
+        {
+            if (m_runnableContexts.Empty())
+                return NULL;
+
+            InternalContextBase *pContext = m_runnableContexts.Dequeue();
+#if defined(_DEBUG)
+            SetContextDebugBits(pContext, CTX_DEBUGBIT_REMOVEDFROMRUNNABLES);
+#endif // _DEBUG
+            return pContext;
+        }
+    };
+
+    class CacheLocalScheduleGroup : public ScheduleGroupBase
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a new cache local schedule group.
+        /// </summary>
+        CacheLocalScheduleGroup(SchedulerBase *pScheduler, location* pGroupPlacement) :
+            ScheduleGroupBase(pScheduler, pGroupPlacement)
+        {
+            m_kind = CacheLocalScheduling;
+        }
+
+        /// <summary>
+        ///     Places a chore in a mailbox associated with the schedule group which is biased towards tasks being picked up from the specified
+        ///     location.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to mail.
+        /// </param>
+        /// <param name="pPlacement">
+        ///     A pointer to a location where the chore will be mailed.
+        /// </param>
+        /// <returns>
+        ///     The mailbox slot into which the chore was placed.
+        /// </returns>
+        /// <remarks>
+        ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+        ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+        /// </remarks>
+        virtual Mailbox<_UnrealizedChore>::Slot MailChore(_UnrealizedChore * pChore,
+                                                          location * pPlacement,
+                                                          ScheduleGroupSegmentBase ** ppDestinationSegment);
+    protected:
+
+        /// <summary>
+        ///     Allocates a new cache local schedule group segment within the specified group and ring with the specified affinity.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity for the segment.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The scheduling ring to which the newly allocated segment will belong.
+        /// </param>
+        /// <returns>
+        ///     A new cache local schedule group within the specified group and ring with the specified affinity.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase* AllocateSegment(SchedulingRing *pOwningRing, location* pSegmentAffinity)
+        {
+            return _concrt_new CacheLocalScheduleGroupSegment(this, pOwningRing, pSegmentAffinity);
+        }
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Chores.cpp

@@ -0,0 +1,376 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Chores.cpp
+//
+// Miscellaneous implementations of things related to individuals chores
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Sets the attachment state of the chore at the time of stealing.
+    /// </summary>
+    void _UnrealizedChore::_SetDetached(bool _FDetached)
+    {
+        _M_fDetached = _FDetached;
+    }
+
+    /// <summary>
+    ///     To free memory allocated with _InternalAlloc.
+    /// </summary>
+    void _UnrealizedChore::_InternalFree(_UnrealizedChore * _PChore)
+    {
+        ASSERT(_PChore->_M_fRuntimeOwnsLifetime);
+        delete _PChore;
+    }
+
+    /// <summary>
+    ///     Place associated task collection in a safe state.
+    /// </summary>
+    void _UnrealizedChore::_CheckTaskCollection()
+    {
+        //
+        // If _M_pTaskCollection is non-NULL, the chore is still scheduled to a task collection. This is only happening
+        // from a handle destructor and we have blown back through a stack based handle while it's still scheduled. We must
+        // wait. The semantic we choose is that this means cancellation too.
+        //
+        Concurrency::details::_TaskCollectionBase *pBase = _M_pTaskCollection;
+        if (pBase != NULL)
+        {
+            bool fThrow = false;
+
+            if (_M_pChoreFunction == &_UnrealizedChore::_StructuredChoreWrapper)
+            {
+                _StructuredTaskCollection *pTaskCollection = static_cast<_StructuredTaskCollection *>(pBase);
+                fThrow = !pTaskCollection->_TaskCleanup();
+            }
+            else
+            {
+                _TaskCollection *pTaskCollection = static_cast<_TaskCollection *>(pBase);
+                fThrow = !pTaskCollection->_TaskCleanup(true);
+            }
+
+            if (fThrow)
+                throw missing_wait();
+        }
+    }
+
+    /// <summary>
+    ///     Prepares for execution as a stolen chore.
+    /// </summary>
+    void _UnrealizedChore::_PrepareSteal(ContextBase *pContext)
+    {
+        if (_M_pChoreFunction == &_UnrealizedChore::_StructuredChoreWrapper)
+        {
+            _PrepareStealStructured(pContext);
+        }
+        else
+        {
+            _PrepareStealUnstructured(pContext);
+        }
+    }
+
+    /// <summary>
+    ///     Called when a stolen chore from a given cancellation token is canceled.
+    /// </summary>
+    void _UnrealizedChore::_CancelViaToken(ContextBase *pContext)
+    {
+        pContext->CancelEntireContext();
+        pContext->CancelStealers(NULL);
+    }
+
+    /// <summary>
+    ///     Prepares for execution as a stolen chore.
+    /// </summary>
+    void _UnrealizedChore::_PrepareStealStructured(ContextBase *pBaseContext)
+    {
+        InternalContextBase *pContext = static_cast<InternalContextBase *> (pBaseContext);
+
+        if (pContext->GetRootCollection() == NULL)
+        {
+            _StructuredTaskCollection *pTaskCollection = static_cast<_StructuredTaskCollection *> (_M_pTaskCollection);
+            ContextBase *pOriginContext = reinterpret_cast <ContextBase *> (pTaskCollection->_M_pOwningContext);
+
+            pContext->SetRootCollection(pTaskCollection);
+
+            pOriginContext->AddStealer(pContext, false);
+        }
+    }
+
+    /// <summary>
+    ///     Wrapper around execution of a structured chore that performs appropriate notification
+    ///     and exception handling semantics.
+    /// </summary>
+    __declspec(noinline)
+    void __cdecl _UnrealizedChore::_StructuredChoreWrapper(_UnrealizedChore * pChore)
+    {
+        InternalContextBase *pContext = static_cast<InternalContextBase *> (SchedulerBase::FastCurrentContext());
+        // The context could be canceled if it was already prepared for steal (this happens during a block unblock race)
+        ASSERT(pContext != NULL && (!pContext->HasInlineCancellation() || pContext->GetRootCollection() != NULL));
+
+        _StructuredTaskCollection *pTaskCollection = static_cast<_StructuredTaskCollection *> (pChore->_M_pTaskCollection);
+        ContextBase *pOriginContext = reinterpret_cast <ContextBase *> (pTaskCollection->_M_pOwningContext);
+
+        pChore->_PrepareStealStructured(pContext);
+
+        //
+        // This allows cancellation of stolen chores based on a cancellation token between the declaration of a stg and its inlining.
+        //
+        _CancellationTokenState *pTokenState = pTaskCollection->_GetTokenState();
+        _CancellationTokenRegistration *pRegistration = NULL;
+
+        if (_CancellationTokenState::_IsValid(pTokenState))
+        {
+            pRegistration = pTokenState->_RegisterCallback(reinterpret_cast<TaskProc>(&_UnrealizedChore::_CancelViaToken), (ContextBase *)pContext);
+        }
+
+        try
+        {
+            //
+            // We need to consider this a possible interruption point. It's entirely possible that we stole and raced with a
+            // cancellation thread. The collection was canceled after we stole(e.g.: removed from the WSQ) but before we added ourselves
+            // to the stealing chain list above. In this case, the entire context will wait until completion (bad). Immediately
+            // after we go on the list (a memory barrier) we need to check the collection cancellation flag. If the collection is going away,
+            // we need to get out *NOW* otherwise the entire subtree executes.
+            //
+            if (pTaskCollection->_IsAbnormalExit())
+                throw _Interruption_exception();
+
+            pChore->m_pFunction(pChore);
+        }
+        catch(const _Interruption_exception &)
+        {
+            //
+            // If someone manually threw the _Interruption_exception exception, we will have a cancel count but not a canceled context. This
+            // means we need to apply the cancel one level up. Normally, the act of throwing would do that via being caught in the
+            // wait, but this is special "marshaling" for _Interruption_exception.
+            //
+            if (pContext->HasInlineCancellation() && !pContext->IsEntireContextCanceled())
+                pTaskCollection->_Cancel();
+        }
+        catch(...)
+        {
+            //
+            // Track the exception that was thrown here. _RaisedException makes the decision on what
+            // exceptions to keep and what to discard. The flags it sets will indicate to the thread calling ::Wait that it must rethrow.
+            //
+            pTaskCollection->_RaisedException();
+            pTaskCollection->_Cancel();
+        }
+
+        pOriginContext->RemoveStealer(pContext);
+        ASSERT(pContext->GetGoverningTokenState() == NULL);
+
+        //
+        // This allows cancellation of stolen chores based on a cancellation token between the declaration of a stg and its inlining.
+        //
+        if (pRegistration != NULL)
+        {
+            ASSERT(pTokenState != NULL);
+            pTokenState->_DeregisterCallback(pRegistration);
+            pRegistration->_Release();
+        }
+
+        pContext->ClearCancel();
+        pContext->SetRootCollection(NULL);
+        pChore->_M_pTaskCollection = NULL;
+        pTaskCollection->_CountUp();
+    }
+
+    /// <summary>
+    ///     Prepares for execution as a stolen chore.
+    /// </summary>
+    void _UnrealizedChore::_PrepareStealUnstructured(ContextBase *pBaseContext)
+    {
+        InternalContextBase *pContext = static_cast<InternalContextBase *> (pBaseContext);
+
+        if (pContext->GetRootCollection() == NULL)
+        {
+            _TaskCollection* pTaskCollection = static_cast<_TaskCollection *> (_M_pTaskCollection);
+            ContextBase *pOriginContext = reinterpret_cast <ContextBase *> (pTaskCollection->_M_pOwningContext);
+
+            pContext->SetRootCollection(pTaskCollection);
+
+            //
+            // pOriginContext is only safe to touch if the act of stealing from a non-detached context put a hold on that context
+            // to block deletion until we are chained for cancellation.
+            //
+            SafeRWList<ListEntry> *pList = reinterpret_cast<SafeRWList<ListEntry> *> (pTaskCollection->_M_stealTracker);
+            ASSERT(sizeof(pTaskCollection->_M_stealTracker) >= sizeof(*pList));
+
+            if (_M_fDetached)
+            {
+                //
+                // We cannot touch the owning context -- it was detached as of the steal. The chain goes onto the task collection.
+                //
+                pContext->NotifyTaskCollectionChainedStealer();
+                pList->AddTail(&(pContext->m_stealChain));
+            }
+            else
+            {
+                pList->AcquireWrite();
+                pTaskCollection->_M_activeStealersForCancellation++;
+                pList->ReleaseWrite();
+                pOriginContext->AddStealer(pContext, true);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Wrapper around execution of an unstructured chore that performs appropriate notification
+    ///     and exception handling semantics.
+    /// </summary>
+    __declspec(noinline)
+    void __cdecl _UnrealizedChore::_UnstructuredChoreWrapper(_UnrealizedChore * pChore)
+    {
+        InternalContextBase *pContext = static_cast<InternalContextBase *> (SchedulerBase::FastCurrentContext());
+        // The context could be canceled if it was already prepared for steal (this happens during a block unblock race)
+        ASSERT(pContext != NULL && (!pContext->HasInlineCancellation() || pContext->GetRootCollection() != NULL));
+
+        _TaskCollection* pTaskCollection = static_cast<_TaskCollection *> (pChore->_M_pTaskCollection);
+
+        //
+        // pOriginContext is only safe to touch if the act of stealing from a non-detached context put a hold on that context
+        // to block deletion until we are chained for cancellation.
+        //
+        ContextBase *pOriginContext = reinterpret_cast <ContextBase *> (pTaskCollection->_M_pOwningContext);
+        SafeRWList<ListEntry> *pList = reinterpret_cast<SafeRWList<ListEntry> *> (pTaskCollection->_M_stealTracker);
+
+        pChore->_PrepareStealUnstructured(pContext);
+
+        _CancellationTokenState *pTokenState = pTaskCollection->_GetTokenState();
+        _CancellationTokenRegistration *pRegistration = NULL;
+        if (_CancellationTokenState::_IsValid(pTokenState))
+        {
+            pRegistration = pTokenState->_RegisterCallback(reinterpret_cast<TaskProc>(&_UnrealizedChore::_CancelViaToken), (ContextBase *)pContext);
+        }
+
+        //
+        // Waiting on the indirect alias may throw (e.g.: the entire context may have been canceled). If it
+        // throws, we need to deal with appropriate marshaling.
+        //
+        try
+        {
+            //
+            // Set up an indirect alias for this task collection. Any usage of the original task collection
+            // within this stolen chore will automatically redirect through the indirect alias. This allows
+            // preservation of single-threaded semantics within the task collection while allowing it to be "accessed"
+            // from stolen chores (multiple threads).
+            //
+            // This stack based collection will wait on stolen chores at destruction time. In the event the collection is not
+            // used during the steal, this doesn't do much.
+            //
+            _TaskCollection indirectAlias(pTaskCollection, false);
+
+            pContext->SetIndirectAlias(&indirectAlias);
+
+            try
+            {
+                //
+                // We need to consider this a possible interruption point. It's entirely possible that we stole and raced with a
+                // cancellation thread. The collection was canceled after we stole(e.g.: removed from the WSQ) but before we added ourselves
+                // to the stealing chain list above. In this case, the entire context will wait until completion (bad). Immediately
+                // after we go on the list (a memory barrier), we need to check the collection cancellation flag. If the collection is going away,
+                // we need to get out *NOW* otherwise the entire subtree executes.
+                //
+                if (pTaskCollection->_M_pOriginalCollection->_M_exitCode != 0 ||
+                    (_CancellationTokenState::_IsValid(pTokenState) && pTokenState->_IsCanceled()) ||
+                    (pTaskCollection->_M_executionStatus != TASKCOLLECTION_EXECUTION_STATUS_CLEAR &&
+                    pTaskCollection->_M_executionStatus != TASKCOLLECTION_EXECUTION_STATUS_INLINE &&
+                    pTaskCollection->_M_executionStatus != TASKCOLLECTION_EXECUTION_STATUS_INLINE_WAIT_WITH_OVERFLOW_STACK))
+                    throw _Interruption_exception();
+
+                pChore->m_pFunction(pChore);
+            }
+            catch(const _Interruption_exception &)
+            {
+                //
+                // If someone manually threw _Interruption_exception, we will have a cancel count but not a canceled context. This
+                // means we need to apply the cancel one level up. Normally, the act of throwing would do that via being caught in the
+                // wait, but this is special "marshaling" for _Interruption_exception.
+                //
+                if (pContext->HasInlineCancellation() && !pContext->IsEntireContextCanceled())
+                    pTaskCollection->_Cancel();
+            }
+            catch(...)
+            {
+                //
+                // Track the exception that was thrown here and subsequently cancel all work. _RaisedException makes the decision on what
+                // exceptions to keep and what to discard. The flags it sets will indicate to the thread calling ::Wait that it must rethrow.
+                //
+                pTaskCollection->_RaisedException();
+                pTaskCollection->_Cancel();
+            }
+
+            indirectAlias._Wait();
+        }
+        catch(const _Interruption_exception &)
+        {
+            //
+            // If someone manually threw _Interruption_exception out of a task on the indirect alias, the same thing applies as to
+            // a directly stolen chore (above).
+            //
+            if (pContext->HasInlineCancellation() && !pContext->IsEntireContextCanceled())
+                pTaskCollection->_Cancel();
+        }
+        catch(...)
+        {
+            //
+            // Track the exception that was thrown here and subsequently cancel all work. _RaisedException makes the decision on what
+            // exceptions to keep and what to discard. The flags it sets will indicate to the thread calling ::Wait that it must rethrow.
+            //
+            pTaskCollection->_RaisedException();
+            pTaskCollection->_Cancel();
+        }
+
+        pContext->SetIndirectAlias(NULL);
+        ASSERT(pContext->GetGoverningTokenState() == NULL);
+
+        if ( !pChore->_M_fDetached)
+        {
+            //
+            // pOriginContext may die at any point (detachment). When it does, it will transfer the stolen chore trace from the context to the
+            // given task collection (us) under lock. We can, therefore, take this lock and check if we are still okay to check the context.
+            //
+            pList->AcquireWrite();
+
+            if (pContext->IsContextChainedStealer())
+                pOriginContext->RemoveStealer(pContext);
+            else
+                pList->UnlockedRemove(&(pContext->m_stealChain));
+
+            pTaskCollection->_M_activeStealersForCancellation--;
+
+            pList->ReleaseWrite();
+
+        }
+        else
+        {
+            pList->Remove(&(pContext->m_stealChain));
+        }
+
+        if (pRegistration != NULL)
+        {
+            pTokenState->_DeregisterCallback(pRegistration);
+            pRegistration->_Release();
+        }
+
+        pContext->ClearCancel();
+        pContext->ClearAliasTable();
+        pContext->SetRootCollection(NULL);
+        pChore->_M_pTaskCollection = NULL;
+        pTaskCollection->_NotifyCompletedChoreAndFree(pChore);
+    }
+} // namespace details
+
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Context.cpp

@@ -0,0 +1,180 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Context.cpp
+//
+// Implementation of static context APIs
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+/// <summary>
+///     Returns a per scheduler unique identifier for the current context.
+/// </summary>
+/// <returns>
+///     A per scheduler unique identifier for the current context or -1 if no such context exists.
+/// </returns>
+unsigned int Context::Id()
+{
+    const ContextBase *pContext = SchedulerBase::SafeFastCurrentContext();
+    return (pContext != NULL ? pContext->GetId() : UINT_MAX);
+}
+
+/// <summary>
+///     Returns an identifier for the virtual processor the current context is executing on.
+/// </summary>
+/// <returns>
+///     An identifier for the virtual processor the current context is executing on or -1 if there is no such context
+///     or it is not executing on a virtual processor at present.
+/// </returns>
+unsigned int Context::VirtualProcessorId()
+{
+    const ContextBase *pContext = SchedulerBase::SafeFastCurrentContext();
+    return (pContext != NULL ? pContext->GetVirtualProcessorId() : UINT_MAX);
+}
+
+/// <summary>
+///     Returns an identifier for the schedule group the current context is working on.
+/// </summary>
+/// <returns>
+///     An identifier for the schedule group the current context is working on or -1 if there is no such context
+///     or it is not executing a schedule group at present.
+/// </returns>
+unsigned int Context::ScheduleGroupId()
+{
+    const ContextBase *pContext = SchedulerBase::SafeFastCurrentContext();
+    return (pContext != NULL ? pContext->GetScheduleGroupId() : UINT_MAX);
+}
+
+/// <summary>
+///     Causes the current context to block, yielding execution to another context.  If the current
+///     thread does not have a ConcRT context associated with it, it is inducted into one.
+/// </summary>
+void Context::Block()
+{
+    return SchedulerBase::CurrentContext()->Block();
+}
+
+/// <summary>
+///     Yields execution so that another context may execute.  The current context is placed on the
+///     scheduler's list of runnable contexts.  If the current thread does not have a context, it is inducted
+///     into a ConcRT context.  If no other function is available to yield to, the function simply returns.
+/// </summary>
+void Context::Yield()
+{
+    SchedulerBase::CurrentContext()->Yield();
+}
+
+/// <summary>
+///     Yields execution so that another context may execute.  The current context is placed on the
+///     scheduler's list of runnable contexts.  If the current thread does not have a context, it is inducted
+///     into a ConcRT context.  If no other function is available to yield to, the function simply returns.
+///
+///     This is intended for spin loops.
+/// </summary>
+void Context::_SpinYield()
+{
+    SchedulerBase::CurrentContext()->SpinYield();
+}
+
+/// <summary>
+///     Returns an indication of whether the task collection which is currently executing inline on the current context
+///     is in the midst of an active cancellation (or will be shortly).
+/// </summary>
+bool Context::IsCurrentTaskCollectionCanceling()
+{
+    ContextBase *pCurrentContext = SchedulerBase::SafeFastCurrentContext();
+    if (pCurrentContext != NULL)
+    {
+        //
+        // If a structured collection has an unstructured collection as a parent,
+        // then GetExecutingCollection will always return the parent.
+        //
+        _TaskCollectionBase *pCollection = pCurrentContext->GetExecutingCollection();
+        if (pCollection != NULL)
+        {
+            if (pCollection->_IsStructured())
+            {
+                return static_cast<details::_StructuredTaskCollection*>(pCollection)->_IsCanceling();
+            }
+            else if (static_cast<details::_TaskCollection*>(pCollection)->_IsAlias())
+            {
+                return static_cast<details::_TaskCollection*>(pCollection)->_OriginalCollection()->_IsCanceling();
+            }
+            else
+            {
+                return static_cast<details::_TaskCollection*>(pCollection)->_IsCanceling();
+            }
+        }
+    }
+    return false;
+}
+
+/// <summary>
+///     Returns the ConcRT context associated with the current thread.
+/// </summary>
+/// <returns>
+///     A pointer to the ConcRT context associated with the current thread if it exists.  If one does not exist,
+///     a new context is created.
+/// <returns>
+_Ret_notnull_ Context* Context::CurrentContext()
+{
+    return SchedulerBase::CurrentContext();
+}
+
+/// <summary>
+///     Depending on the argument, causes the scheduler to add an extra virtual processor for the
+///     duration of a block of code or remove a previously added one.
+///
+///         Oversubscribe(true);
+///         /* some slow kernel or I/O code, etc.*/
+///         Oversubscribe(false);
+///
+///     An extra virtual processor is allocated on the current hardware thread between the two calls
+///     to Oversubscribe. If additional idle virtual processors are available, the virtual processor is created
+///     and made available, but if no available virtual processors exist, the virtual processor is kicked into
+///     action with an internal context that searches for work.
+///     Calls to Oversubscribe(TRUE) must be matched with calls to Oversubscribe(FALSE) -> calls can be nested,
+///     but only a maximum of one additional virtual processor is created. The additional vproc, if any, will
+///     be retired after the outermost call to Oversubscribe(FALSE), as soon as the currently executing root
+///     chore on the vproc is completed.
+/// </summary>
+/// <param name="beginOversubscription">
+///     [in] A boolean value specifying whether oversubscription is to be turned on or off.
+/// </param>
+void Context::Oversubscribe(bool beginOversubscription)
+{
+    SchedulerBase::CurrentContext()->Oversubscribe(beginOversubscription);
+}
+
+namespace details
+{
+    _Context _Context::_CurrentContext()
+    {
+        return _Context(SchedulerBase::CurrentContext());
+    }
+
+    void _Context::_Yield()
+    {
+        SchedulerBase::CurrentContext()->Yield();
+    }
+
+    void _Context::_Oversubscribe(bool _BeginOversubscription)
+    {
+        SchedulerBase::CurrentContext()->Oversubscribe(_BeginOversubscription);
+    }
+
+    bool _Context::_IsSynchronouslyBlocked() const
+    {
+        return _M_pContext->IsSynchronouslyBlocked();
+    }
+}
+
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ContextBase.cpp

@@ -0,0 +1,1341 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ContextBase.cpp
+//
+// Source file containing the implementation for an execution ContextBase/stack/thread.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#include "concrtinternal.h"
+
+#pragma warning (disable : 4702)
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Constructor
+    /// </summary>
+    ContextBase::ContextBase(SchedulerBase *pScheduler, bool fIsExternal) :
+        m_criticalRegionCount(0),
+        m_hyperCriticalRegionCount(0),
+        m_oversubscribeCount(0),
+        m_pScheduler(pScheduler),
+        m_pWorkQueue(NULL),
+        m_pParentContext(NULL),
+        m_blockedState(CONTEXT_BLOCKED),
+        m_contextSwitchingFence(0),
+        m_pRootCollection(NULL),
+        m_pExecutingCollection(NULL),
+        m_pGoverningTokenState(NULL),
+        m_governingTokenDepth(-1),
+        m_asyncTaskCollectionInlineDepth(0),
+        m_threadId(0),
+        m_fIsExternal(fIsExternal),
+#if defined(_DEBUG)
+        m_fShutdownValidations(false),
+#endif // _DEBUG
+        m_cancellationRefCount(0),
+        m_minCancellationDepth(-1),
+        m_maxCancellationDepth(-1),
+        m_inlineCancellations(0),
+        m_canceledContext(0),
+        m_pendingCancellations(0),
+        m_pIndirectAlias(NULL),
+        //
+        // The alias table must be sufficiently small that clearing it at the end of a stolen chore isn't a huge penalty, yet
+        // large enough to splay a few task collections. Hopefully, the number of collections being utilized in stolen chores isn't very
+        // large (1 or 2), so this size should be sufficient.
+        //
+        m_aliasTable(7)
+    {
+        m_id = m_pScheduler->GetNewContextId();
+        TraceContextEvent(CONCRT_EVENT_START, TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);
+    }
+
+    unsigned int ContextBase::ScheduleGroupRefCount() const
+    {
+        return m_pSegment != NULL ? (unsigned int)m_pSegment->GetGroup()->m_refCount : UINT_MAX;
+    }
+
+    /// <summary>
+    ///     Returns a unique identifier to the context
+    /// </summary>
+    unsigned int ContextBase::GetId() const
+    {
+        return m_id;
+    }
+
+    /// <summary>
+    ///     Returns an identifier to the schedule group the context is currently working on, if any.
+    /// </summary>
+    unsigned int ContextBase::GetScheduleGroupId() const
+    {
+        return (m_pSegment != NULL) ? m_pSegment->GetGroup()->Id() : UINT_MAX;
+    }
+
+    /// <summary>
+    ///     Places a reference on the context preventing it from being destroyed until such time as the stealer is added to the chain
+    ///     via AddStealer. Note that the operation of AddStealer should happen rapidly as it will *BLOCK* cleanup of the context.
+    /// </summary>
+    void ContextBase::ReferenceForCancellation()
+    {
+        InterlockedIncrement(&m_cancellationRefCount);
+    }
+
+    /// <summary>
+    ///     Removes a reference on the context which was preventing it from being destroyed.
+    /// </summary>
+    void ContextBase::DereferenceForCancellation()
+    {
+        InterlockedDecrement(&m_cancellationRefCount);
+    }
+
+    /// <summary>
+    ///     Adds a stealing context.
+    /// </summary>
+    void ContextBase::AddStealer(ContextBase *pStealer, bool fDereferenceForCancellation)
+    {
+        m_stealers.AddTail(&(pStealer->m_stealChain));
+        pStealer->m_fContextChainedStealer = true;
+        if (fDereferenceForCancellation)
+            DereferenceForCancellation();
+    }
+
+    /// <summary>
+    ///     Removes a stealing context.
+    /// </summary>
+    void ContextBase::RemoveStealer(ContextBase *pStealer)
+    {
+        m_stealers.Remove(&(pStealer->m_stealChain));
+    }
+
+    /// <summary>
+    ///     Cancel everything stolen from pCanceledCollection outward from this context.
+    /// </summary>
+    void ContextBase::CancelStealers(_TaskCollectionBase *pCanceledCollection)
+    {
+        ASSERT(pCanceledCollection != NULL || IsEntireContextCanceled());
+
+        SafeRWList<ListEntry>::_Scoped_lock_read readLock(m_stealers);
+        ListEntry *pLE = m_stealers.First();
+        while (pLE != NULL)
+        {
+            ContextBase *pStealingContext = CONTAINING_RECORD(pLE, ContextBase, m_stealChain);
+
+            //
+            // We don't want to be recursively traversing the tree needlessly every time the exception propagates back
+            // up a given context. If a context is already canceled, nothing can steal from it and we don't need to traverse
+            // there.
+            //
+            if (!pStealingContext->IsEntireContextCanceled())
+            {
+                _TaskCollectionBase *pRootCollection = pStealingContext->GetRootCollection();
+                ASSERT(pRootCollection != NULL);
+                //
+                // If pCanceledCollection != NULL, it is an indication that we're at the first level. We can only cancel things that are stolen
+                // from greater inlining depth or things from equal if the root collection is pCollection. Further, we cannot cancel things which are not
+                // inlined. For example:
+                //
+                // _TaskCollection p1;
+                // p1.Schedule( [] {
+                //      _TaskCollection *p2 = new _TaskCollection;
+                //      p2.Schedule(alpha);
+                //      _TaskCollection p3;
+                //      p3.Schedule( [] {
+                //          Blah;
+                //          });
+                //      });
+                //
+                // A cancel of p1 while p1->p3 is running inline cannot cancel p2. The exception that backflows might indeed cancel p2 if it was stack
+                // based, but remember we can have task collection pointers which are passed amongst threads and detached.
+                //
+                // Keep in mind that it's entirely possible to have a situation similar to above during the recursion where one of the stolen chores declared
+                // a task collection and pushed chores that will not be waited upon but instead will be passed out to another thread. We cannot tear down contexts
+                // that stole in this manner either.
+                //
+
+                if (
+                    // A context whose root chore belongs to the task collection being canceled is fair game. No further checks are required.
+                    (pRootCollection == pCanceledCollection) ||
+
+                    // On recursion, as long as the root collection is inlined (no matter the depth), we are safe to cancel as it was inlined on a canceled
+                    // context and that by definition gives it the correct parentage to be shot down.
+                    (pCanceledCollection == NULL && pRootCollection->_IsCurrentlyInlined()) ||
+
+                    // The only way cancellation can be satisfied if both aren't inlined is above. Otherwise, the one that stole must have greater
+                    // inline depth than the one we're canceling.
+                    (pCanceledCollection != NULL && pCanceledCollection->_IsCurrentlyInlined() && pRootCollection->_InliningDepth() > pCanceledCollection->_InliningDepth())
+                   )
+                {
+                    ASSERT(pRootCollection == pCanceledCollection || pCanceledCollection == NULL || pRootCollection->_IsCurrentlyInlined());
+                    //
+                    // We must verify that it is okay to cancel the stealer based on any tokens which are present on 'this' context. We are further guaranteed
+                    // stability on the inlining depth because of the lock on the stealers list.
+                    //
+                    bool fCancel = true;
+                    if (pRootCollection != pCanceledCollection && m_governingTokenDepth != -1)
+                    {
+                        ASSERT(pRootCollection->_IsCurrentlyInlined() && m_pGoverningTokenState != NULL);
+                        fCancel = IsCanceledAtDepth(pRootCollection);
+                    }
+
+                    if (fCancel)
+                    {
+                        pStealingContext->CancelEntireContext();
+                        pStealingContext->CancelStealers(NULL);
+                    }
+                }
+            }
+
+            pLE = m_stealers.Next(pLE);
+        }
+    }
+
+    /// <summary>
+    ///     Cleans up the context.
+    /// </summary>
+    void ContextBase::Cleanup()
+    {
+        ReleaseWorkQueue();
+
+        TraceContextEvent(CONCRT_EVENT_END, TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);
+    }
+
+    /// <summary>
+    ///     Called on both internal and external contexts, either when the are put into an idle pool to
+    ///     be recycled, or when they are ready to be deleted. The API moves the contexts that are in
+    ///     the list of 'stealers' (used for cancellation) to lists in the task collections from which
+    ///     those contexts have stolen chores.
+    /// </summary>
+    void ContextBase::DetachStealers()
+    {
+        //
+        // Make sure no one has a ref on us to add to the stealers list. We need to wait on that before running down the cancellation list.
+        // Note that waiting here should be *EXTREMELY RARE*. The only time we'd ever see it would be if a task collection was used between threads and
+        // and between the time of the steal and the time the wrapper executed the original thread went away.
+        //
+
+        if (m_cancellationRefCount != 0)
+        {
+            // Spin wait (no yielding)
+            _SpinWaitNoYield spinWait;
+
+            do
+            {
+                spinWait._SpinOnce();
+
+            } while (m_cancellationRefCount != 0);
+        }
+
+        if (m_aliasTable.Count() > 0)
+            ClearAliasTable();
+
+        if (m_stealers.Empty())
+        {
+            //
+            // After a DetachStealers, it is entirely possible that the context (the *this*) pointer goes away. Normally, the lock on the stealers
+            // list is what guards against manipulation by stolen chores; however -- the early exit above presents an interesting risk. It is now entirely
+            // possible that the last stolen chore is removing its context from the stealers list under the governance of the write lock and makes the
+            // list empty. The detachment wants to bail due to the above check (there's nothing there) and the context pointer is freed before the stealing
+            // thread releases the write lock.
+            //
+            // We do want the early bail to avoid taking and releasing a reader/writer frequently in this case for scenarios like parallel for. In order to
+            // prevent touching freed memory, we need to flush out any write owner (take and release the lock if someone holds a write).
+            //
+            m_stealers.FlushWriteOwners();
+            return;
+        }
+
+        //
+        // If there is anything left on the stealers list, it means that a context is dying while a task collection bound to that context lives
+        // on and still has stolen chores. In order to continue to facilitate cancellation of those task collections, any stealers in the list have
+        // to be moved to the individual task collection lists.
+        //
+        bool isDone = false;
+
+        while(!isDone)
+        {
+            bool fContinue = true;
+            m_stealers.AcquireWrite();
+            __try
+            {
+                fContinue = true;
+                ListEntry *pEntry = m_stealers.First();
+                while (pEntry != NULL && fContinue)
+                {
+                    ListEntry *pNext = m_stealers.Next(pEntry);
+
+                    ContextBase *pContext = CONTAINING_RECORD(pEntry, ContextBase, m_stealChain);
+
+                    _TaskCollectionBase *pCollectionBase = pContext->GetRootCollection();
+                    ASSERT(pCollectionBase != NULL && !pCollectionBase->_IsStructured());
+
+                    _TaskCollection *pCollection = static_cast<_TaskCollection *>(pCollectionBase);
+
+                    //
+                    // In all likelihood, we rarely get here; however -- there is an issue in that the lock ordering here is from the bottom up
+                    // (task collection then context) in order to preserve patterns in stealing and cancellation.
+                    //
+                    // When we move, we must do so in a backwards order. The only time we should see contention on these locks is during minimal
+                    // periods where we are cancelling or for tiny time frames during steal. We will play a pseudo-atomic lock acquire game. If we cannot
+                    // get both, we back off and let the other thread through.
+                    //
+                    SafeRWList<ListEntry> *pCollectionList = reinterpret_cast<SafeRWList<ListEntry> *> (pCollection->_GetStealTrackingList());
+                    if (!pCollectionList->TryAcquireWrite())
+                    {
+                        //
+                        // Yield in an attempt to force the other thread through.
+                        //
+                        m_stealers.ReleaseWrite();
+                        fContinue = false;
+                        platform::__Sleep(1);
+                        break;
+                    }
+
+                    __try
+                    {
+                        m_stealers.UnlockedRemove(&(pContext->m_stealChain));
+                        pContext->m_fContextChainedStealer = false;
+                        pCollectionList->UnlockedAddTail(&(pContext->m_stealChain));
+                    }
+                    __finally
+                    {
+                        pCollectionList->ReleaseWrite();
+                    }
+
+                    pEntry = pNext;
+                }
+
+                isDone = (pEntry == NULL);
+            }
+            __finally
+            {
+                //
+                // It may have been released due to a back-off.
+                //
+                if (fContinue)
+                {
+                    m_stealers.ReleaseWrite();
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Pushes an unrealized chore onto the work stealing queue for structured parallelism.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to push onto the structured work stealing queue.
+    /// </param>
+    void ContextBase::PushStructured(_UnrealizedChore *pChore, location *pLocation)
+    {
+        Mailbox<_UnrealizedChore>::Slot affinitySlot;
+
+        // If the chore has been scheduled with a location and the scheduler supports location-based scheduling, the destination schedule
+        // group segment may be different from the current one.
+        ScheduleGroupSegmentBase * pDestinationSegment = m_pSegment;
+
+        if (pLocation != NULL)
+        {
+            //
+            // If the current segment this context is operating within has the same affinity as the requested task, there is *NO NEED* to mail
+            // the task anywhere. It will get a natural affinity to pLocation without any additional work.
+            //
+            if (!pLocation->_Is_system())
+            {
+                if (*pLocation != m_pSegment->GetAffinity())
+                {
+                    affinitySlot = m_pSegment->GetGroup()->MailChore(pChore, pLocation, &pDestinationSegment);
+                }
+
+                pDestinationSegment->NotifyAffinitizedWork();
+            }
+        }
+
+        GetStructuredWorkQueue()->PushStructured(pChore, affinitySlot);
+
+        //
+        // Update the enqueued task numbers for statistics. Since this is a critical performance
+        // path we avoid making a virtual call since that will imply two memory dereferences plus
+        // an indirect call. Instead, we make one memory dereference to get a condition and one
+        // branch. This is faster ONLY because target function call will be inlined.
+        //
+        if (IsExternal())
+        {
+            static_cast<ExternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+        else
+        {
+            static_cast<InternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+
+        if (m_pScheduler->HasVirtualProcessorAvailableForNewWork())
+        {
+            m_pScheduler->StartupNewVirtualProcessor(pDestinationSegment, pDestinationSegment->GetAffinity());
+        }
+    }
+
+    /// <summary>
+    ///     Pushes an unrealized chore onto the work stealing queue for structured parallelism.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to push onto the structured work stealing queue.
+    /// </param>
+    void ContextBase::PushStructured(_UnrealizedChore *pChore)
+    {
+        GetStructuredWorkQueue()->PushStructured(pChore);
+
+        //
+        // Update the enqueued task numbers for statistics. Since this is a critical performance
+        // path we avoid making a virtual call since that will imply two memory dereferences plus
+        // an indirect call. Instead, we make one memory dereference to get a condition and one
+        // branch. This is faster ONLY because target function call will be inlined.
+        //
+        if (IsExternal())
+        {
+            static_cast<ExternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+        else
+        {
+            static_cast<InternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+
+        if (m_pScheduler->HasVirtualProcessorAvailableForNewWork())
+        {
+            m_pScheduler->StartupNewVirtualProcessor(m_pSegment);
+        }
+    }
+
+    /// <summary>
+    ///     Pushes an unrealized chore onto the work stealing queue for unstructured parallelism.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to push onto the unstructured work stealing queue.
+    /// </param>
+    int ContextBase::PushUnstructured(_UnrealizedChore *pChore, location *pLocation)
+    {
+        Mailbox<_UnrealizedChore>::Slot affinitySlot;
+
+        // If the chore has been scheduled with a location and the scheduler supports location-based scheduling, the destination schedule
+        // group segment may be different from the current one.
+        ScheduleGroupSegmentBase * pDestinationSegment = m_pSegment;
+
+        if (pLocation != NULL)
+        {
+            //
+            // If the current segment this context is operating within has the same affinity as the requested task, there is *NO NEED* to mail
+            // the task anywhere. It will get a natural affinity to pLocation without any additional work.
+            //
+            if (!pLocation->_Is_system())
+            {
+                if (*pLocation != m_pSegment->GetAffinity())
+                {
+                    affinitySlot = m_pSegment->GetGroup()->MailChore(pChore, pLocation, &pDestinationSegment);
+                }
+
+                pDestinationSegment->NotifyAffinitizedWork();
+            }
+        }
+
+        int cookie = GetWorkQueue()->PushUnstructured(pChore, affinitySlot);
+
+        //
+        // Update the enqueued task numbers for statistics. Since this is a critical performance
+        // path we avoid making a virtual call since that will imply two memory dereferences plus
+        // an indirect call. Instead, we make one memory dereference to get a condition and one
+        // branch. This is faster ONLY because target function call will be inlined.
+        //
+        if (IsExternal())
+        {
+            static_cast<ExternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+        else
+        {
+            static_cast<InternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+
+        if (m_pScheduler->HasVirtualProcessorAvailableForNewWork())
+        {
+            m_pScheduler->StartupNewVirtualProcessor(pDestinationSegment, pDestinationSegment->GetAffinity());
+        }
+
+        return cookie;
+    }
+
+    /// <summary>
+    ///     Pushes an unrealized chore onto the work stealing queue for unstructured parallelism.
+    /// </summary>
+    /// <param name="pChore">
+    ///     The chore to push onto the unstructured work stealing queue.
+    /// </param>
+    int ContextBase::PushUnstructured(_UnrealizedChore *pChore)
+    {
+        int cookie = GetWorkQueue()->PushUnstructured(pChore);
+
+        //
+        // Update the enqueued task numbers for statistics. Since this is a critical performance
+        // path we avoid making a virtual call since that will imply two memory dereferences plus
+        // an indirect call. Instead, we make one memory dereference to get a condition and one
+        // branch. This is faster ONLY because target function call will be inlined.
+        //
+        if (IsExternal())
+        {
+            static_cast<ExternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+        else
+        {
+            static_cast<InternalContextBase *>(this)->IncrementEnqueuedTaskCounter();
+        }
+
+        if (m_pScheduler->HasVirtualProcessorAvailableForNewWork())
+        {
+            m_pScheduler->StartupNewVirtualProcessor(m_pSegment);
+        }
+
+        return cookie;
+    }
+
+    /// <summary>
+    ///     Pops the topmost chore from the work stealing queue for structured parallelism. Failure
+    ///     to pop typically indicates stealing.
+    /// </summary>
+    /// <returns>
+    ///     An unrealized chore from the structured work stealing queue or NULL if none is present.
+    /// </returns>
+    _UnrealizedChore *ContextBase::PopStructured()
+    {
+        ASSERT(m_pWorkQueue != NULL);
+        _UnrealizedChore *pChore = m_pWorkQueue->PopStructured();
+
+        return pChore;
+    }
+
+    /// <summary>
+    ///     Attempts to pop the chore specified by a cookie value from the unstructured work stealing queue. Failure
+    ///     to pop typically indicates stealing.
+    /// </summary>
+    /// <param name="cookie">
+    ///     A cookie returned from PushUnstructured indicating the chore to attempt to pop from
+    ///     the unstructured work stealing queue.
+    /// </param>
+    /// <returns>
+    ///     The specified unrealized chore (as indicated by cookie) or NULL if it could not be popped from
+    ///     the work stealing queue
+    /// </returns>
+    _UnrealizedChore *ContextBase::TryPopUnstructured(int cookie)
+    {
+        ASSERT(m_pWorkQueue != NULL);
+        _UnrealizedChore *pChore = m_pWorkQueue->TryPopUnstructured(cookie);
+
+        return pChore;
+    }
+
+    /// <summary>
+    ///     Sweeps the unstructured work stealing queue for items matching a predicate and potentially removes them
+    ///     based on the result of a callback.
+    /// </summary>
+    /// <param name="pPredicate">
+    ///     The predicate for things to call pSweepFn on.
+    /// </param>
+    /// <param name="pData">
+    ///     The data for the predicate callback
+    /// </param>
+    /// <param name="pSweepFn">
+    ///     The sweep function
+    /// </param>
+    void ContextBase::SweepUnstructured(WorkStealingQueue<_UnrealizedChore>::SweepPredicate pPredicate,
+                                        void *pData,
+                                        WorkStealingQueue<_UnrealizedChore>::SweepFunction pSweepFn
+                                        )
+    {
+        ASSERT(m_pWorkQueue != NULL);
+        return m_pWorkQueue->SweepUnstructured(pPredicate, pData, pSweepFn);
+    }
+
+    /// <summary>
+    ///     Create a workqueue for use in unstructured task collections.
+    /// </summary>
+    void ContextBase::CreateWorkQueue()
+    {
+        //
+        // First try and reuse a detached workqueue.
+        //
+        m_pWorkQueue = m_pSegment->GetDetachedWorkQueue();
+        //
+        // A detached work queue is still on m_pGroup->m_workQueues.
+        //
+        if (m_pWorkQueue == NULL)
+        {
+            //
+            // If that failed, try and reuse a workqueue from the free pool.
+            //
+            m_pWorkQueue = m_pSegment->m_workQueues.PullFromFreePool();
+
+            if (m_pWorkQueue == NULL)
+            {
+                //
+                // Must create a new one.
+                //
+                m_pWorkQueue = _concrt_new WorkQueue();
+            }
+            else
+            {
+                //
+                // Reinitialize the work queue from the free pool.
+                //
+                m_pWorkQueue->Reinitialize();
+            }
+
+            m_pSegment->m_workQueues.Add(m_pWorkQueue);
+        }
+
+        ASSERT(m_pWorkQueue != NULL);
+        m_pWorkQueue->SetOwningContext(this);
+    }
+
+    /// <summary>
+    ///     Create a workqueue for use in structured task collections.
+    /// </summary>
+    void ContextBase::CreateStructuredWorkQueue()
+    {
+        //
+        // First, try and reuse a workqueue from the free pool.
+        // When using structured task collections, quite often there are
+        // no previous unstructured task collections that neglected to wait (thus generating detached workqueues).
+        //
+        m_pWorkQueue = m_pSegment->m_workQueues.PullFromFreePool();
+
+        if (m_pWorkQueue == NULL)
+        {
+            //
+            // If that failed, see if there is a workqueue on the detachedWorkQueues list to reuse.
+            //
+            m_pWorkQueue = m_pSegment->GetDetachedWorkQueue();
+
+            //
+            // A detached work queue is still on m_pSegment->m_workQueues.
+            //
+            if (m_pWorkQueue == NULL)
+            {
+                m_pWorkQueue = _concrt_new WorkQueue();
+                m_pSegment->m_workQueues.Add(m_pWorkQueue);
+            }
+        }
+        else
+        {
+            //
+            // Reinitialize the work queue from the free pool.
+            //
+            m_pWorkQueue->Reinitialize();
+            m_pSegment->m_workQueues.Add(m_pWorkQueue);
+        }
+
+        ASSERT(m_pWorkQueue != NULL);
+        m_pWorkQueue->SetOwningContext(this);
+    }
+
+    /// <summary>
+    ///     Cleans up the internal workqueue.
+    /// </summary>
+    void ContextBase::ReleaseWorkQueue()
+    {
+        if (m_pWorkQueue != NULL)
+        {
+            //
+            // It's entirely possible that this particular work queue had chores left on the unstructured work queue.
+            // Someone could create an unstructured task collection within an LWT, queue chores, and subsequently pass
+            // the collection out of the LWT to be waited upon later. In this case, we must leave the work queue around
+            // in order for stealing to appropriately happen. This work queue will not be dechained from the schedule
+            // group, but will remain until empty. It will go on a lookaside and, while in this state, can be handed
+            // to some new context working on an item within the same schedule group.
+            //
+
+            // Save off a local copy of the workqueue and work with that. The debugger mines the workqueue information
+            // held in this context, and if we remove the work queue while it's still pointed at by this context, the
+            // debugger can become confused.
+            WorkQueue* workQueue = m_pWorkQueue;
+            m_pWorkQueue = NULL;
+
+            if ( !workQueue->IsUnstructuredEmpty())
+            {
+                workQueue->LockedSetOwningContext(NULL);
+                m_pSegment->DetachActiveWorkQueue(workQueue);
+            }
+            else
+            {
+                //
+                // Unless someone really side-stepped the intent of _StructuredTaskCollection, it's almost certain that
+                // workQueue->IsStructuredEmpty() is true or else a missing_wait was already thrown.
+                //
+                if (workQueue->IsLockHeld())
+                {
+                    // Somebody is stealing, don't want to NULL out owning ctx until they're done.
+                    workQueue->LockedSetOwningContext(NULL);
+                }
+                else
+                {
+                    // We know workQueue has no unstructured, since we're on the owning thread.
+                    // Moreover, structured must be empty at this point, because we cannot ever get here until the wait is satisfied.
+                    // If the UnlockedSteal is entered, then we'll early exit w/o ever touching the owning ctx of workQueue.
+                    workQueue->SetOwningContext(NULL);
+                }
+                m_pSegment->m_workQueues.Remove(workQueue);
+            }
+        }
+
+        //
+        // Make sure that any detachment triggers the stealers to move into the task collection list. Otherwise, we can wind up with
+        // an A<-B<-A stealing pattern:
+        //
+        // TC 1 on thread A
+        //   Thread B steals from TC 1 (A<-B)
+        //   Thread A detaches (no wait on TC1)
+        //   Thread A does SFW and steals from TC 2 deeper inline on thread B (B<-A)
+        //
+        // The overall stealers pattern is A<-B<-A which will wind up with lock traversal in this order. The recursive reacquire of
+        // R/W lock (or out of order acquire: A<-B on one thread, B<-A on the other) will result in later deadlock.
+        //
+        DetachStealers();
+    }
+
+    /// <summary>
+    ///     Sets the 'this' context into the tls slot as the current context. This is used by internal contexts in
+    ///     their dispatch loops.
+    /// </summary>
+    void ContextBase::SetAsCurrentTls()
+    {
+        platform::__TlsSetValue(SchedulerBase::t_dwContextIndex, this);
+    }
+
+    /// <summary>
+    ///     When schedulers are nested on the same thread, the nested scheduler creates a new external context that overrides
+    ///     the previous context. PopContextFromTls will restore the previous context by setting the TLS value appropriately.
+    /// </summary>
+    ContextBase* ContextBase::PopContextFromTls()
+    {
+        ContextBase* pPreviousContext = m_pParentContext;
+        platform::__TlsSetValue(SchedulerBase::t_dwContextIndex, pPreviousContext);
+        m_pParentContext = NULL;
+        return pPreviousContext;
+    }
+
+    /// <summary>
+    ///     When schedulers are nested on the same thread, the nested scheduler creates a new external context that overrides
+    ///     the previous context. PushContextToTls will store the previous context and set the new context into TLS.
+    /// </summary>
+    void ContextBase::PushContextToTls(ContextBase* pParentContext)
+    {
+        m_pParentContext = pParentContext;
+
+        // For the first context on a thread, we expect the TLS values to be null. If there is a parent context,
+        // the TLS value should have been cleared right before nesting.
+        ASSERT(platform::__TlsGetValue(SchedulerBase::t_dwContextIndex) == NULL);
+        platform::__TlsSetValue(SchedulerBase::t_dwContextIndex, this);
+    }
+
+    /// <summary>
+    ///     Context TLS is cleared during nesting on internal contexts before the external context TLS is correctly setup. If not,
+    ///     code that executes between the clear and setting the new TLS could get confused.
+    /// </summary>
+    void ContextBase::ClearContextTls()
+    {
+        ASSERT(platform::__TlsGetValue(SchedulerBase::t_dwContextIndex) != NULL);
+        platform::__TlsSetValue(SchedulerBase::t_dwContextIndex, NULL);
+    }
+
+    /// <summary>
+    ///     Returns the scheduler the specified context is associated with.
+    /// </summary>
+    SchedulerBase* ContextBase::GetScheduler() const
+    {
+        return m_pScheduler;
+    }
+
+    /// <summary>
+    ///     Returns the schedule group the specified context is associated with.
+    /// </summary>
+    ScheduleGroupBase* ContextBase::GetScheduleGroup() const
+    {
+        return m_pSegment != NULL ? m_pSegment->GetGroup() : NULL;
+    }
+
+    /// <summary>
+    ///     Returns the schedule group the specified context is associated with.
+    /// </summary>
+    ScheduleGroupSegmentBase* ContextBase::GetScheduleGroupSegment() const
+    {
+        return m_pSegment;
+    }
+
+    /// <summary>
+    ///     Gets the indirect alias.
+    /// </summary>
+    _TaskCollection *ContextBase::GetIndirectAlias() const
+    {
+        return m_pIndirectAlias;
+    }
+
+    /// <summary>
+    ///     Sets the indirect alias.
+    /// </summary>
+    void ContextBase::SetIndirectAlias(_TaskCollection *pAlias)
+    {
+        m_pIndirectAlias = pAlias;
+    }
+
+    /// <summary>
+    ///     Sweeps the alias table removing anything that's marked for delete. This is done every time we create a new direct alias
+    ///     in order to avoid growing the table arbitrarily for a context which isn't going away. Note -- passing a task collection between
+    ///     threads is expensive the first time it's used.
+    /// </summary>
+    void ContextBase::SweepAliasTable()
+    {
+        int x;
+        Hash<_TaskCollection*, _TaskCollection*>::ListNode *pNode = m_aliasTable.First(&x);
+        while (pNode != NULL)
+        {
+            Hash<_TaskCollection*, _TaskCollection*>::ListNode *pNextNode = m_aliasTable.Next(&x, pNode);
+
+            if (pNode->m_value->_IsStaleAlias())
+            {
+                _TaskCollection *pCollection = pNode->m_value;
+                m_aliasTable.Delete(pCollection->_OriginalCollection()); // may delete pNode
+                delete pCollection;
+            }
+
+            pNode = pNextNode;
+        }
+    }
+
+    /// <summary>
+    ///     Clears the alias table.
+    /// </summary>
+    void ContextBase::ClearAliasTable()
+    {
+        int x;
+        Hash<_TaskCollection*, _TaskCollection*>::ListNode *pNode = m_aliasTable.First(&x);
+        while (pNode != NULL)
+        {
+            pNode->m_value->_ReleaseAlias();
+            pNode = m_aliasTable.Next(&x, pNode);
+        }
+        m_aliasTable.Wipe();
+    }
+
+    /// <summary>
+    ///     Sets the cancellation token currently governing this context.
+    /// </summary>
+    void ContextBase::PushGoverningTokenState(_CancellationTokenState *pTokenState, int inliningDepth)
+    {
+        ASSERT(SchedulerBase::FastCurrentContext() == this);
+        m_pGoverningTokenState = pTokenState;
+        m_governingTokenDepth = inliningDepth;
+    }
+
+    /// <summary>
+    ///     Reverts to the previously set cancellation token.
+    /// </summary>
+    void ContextBase::PopGoverningTokenState(_CancellationTokenState *pTokenState)
+    {
+        ASSERT(SchedulerBase::FastCurrentContext() == this);
+        ASSERT(m_pGoverningTokenState == pTokenState);
+        ASSERT(m_pExecutingCollection->_InliningDepth() == m_governingTokenDepth);
+
+        // Move back up to find the parent. Even if the parent has the same token, we need to change the
+        // governing token depth to *its* inlining depth
+        _TaskCollectionBase *pCollection = m_pExecutingCollection->_SafeGetParent();
+
+        while (pCollection != NULL && pCollection != m_pRootCollection && pCollection->_GetTokenState() == NULL)
+        {
+            pCollection = pCollection->_SafeGetParent();
+        }
+        //
+        // We only keep governing tokens for THIS context.
+        //
+        if (pCollection != NULL && pCollection != m_pRootCollection)
+        {
+            ASSERT(pCollection->_GetTokenState() != NULL && pCollection->_InliningDepth() != -1);
+            m_pGoverningTokenState = pCollection->_GetTokenState();
+            m_governingTokenDepth = pCollection->_M_inliningDepth;
+        }
+        else
+        {
+            m_pGoverningTokenState = NULL;
+            m_governingTokenDepth = -1;
+        }
+    }
+
+    /// <summary>
+    ///     Called in order to indicate that a collection executing on this context was canceled. This will often cause cancellation
+    ///     and unwinding of the entire context (up to the point where we get to the canceled collection). This method is paired with
+    ///     CancelCollectionComplete.
+    ///     NOTE: Callers of CancelCollection must first guarantee through other means that the collection they're cancelling (the one at the
+    ///     depth by the argument) will have a stable inlining depth through the duration of the CancelCollection call.
+    ///         *   For structured task collections, since cancel is only allowed to be called by the owning context or within a stolen chore, if an
+    ///     inlining depth greater than zero is observed, it is stable since the owning thread will have to wait until the chore invoking CancelCollection
+    ///     completes.
+    ///         *   For general task collections, cancel is allowed from arbitrary threads. If the calling thread is an indirect alias, the inlining
+    ///     depth will be stable if observed to be greater than 0 (because CancelCollection is executing inside a stolen chore). Alternatively the thread can use
+    ///     a CAS based state lock (see _TaskCollection::_CancelFromArbitraryThread) to ensure that inlining depth is stable.
+    /// </summary>
+    void ContextBase::CancelCollection(int inliningDepth)
+    {
+        InterlockedIncrement(&m_inlineCancellations);
+
+        long curDepth = m_minCancellationDepth;
+        //
+        // Keep track of the minimum cancellation depth.
+        //
+        for(;;)
+        {
+            if (curDepth != -1 && inliningDepth > curDepth)
+                break;
+
+            long xchgDepth = InterlockedCompareExchange(&m_minCancellationDepth, inliningDepth, curDepth);
+            if (xchgDepth == curDepth)
+            {
+                //
+                // Cancellation beacons are a bit different. If the entire context was canceled due to a steal, we flag top level cancellation
+                // beacons even though they are not considered to have inlining depth since the caller might not have been inlined.
+                //
+                FlagCancellationBeacons(IsEntireContextCanceled() ? -1 : inliningDepth);
+                break;
+            }
+            curDepth = xchgDepth;
+        }
+
+        long curMaxDepth = m_maxCancellationDepth;
+        //
+        // Keep track of the maximum cancellation depth
+        //
+        for(;;)
+        {
+            if (curMaxDepth != -1 && inliningDepth < curMaxDepth)
+                break;
+
+            long xchgDepth = InterlockedCompareExchange(&m_maxCancellationDepth, inliningDepth, curMaxDepth);
+            if (xchgDepth == curMaxDepth)
+            {
+                break;
+            }
+            curMaxDepth = xchgDepth;
+        }
+    }
+
+    /// <summary>
+    ///     Recomputes the maximum depth of cancellation after a canceled task group clears its cancellation flag.
+    /// </summary>
+    void ContextBase::RecomputeMaximumCancellationDepth()
+    {
+        //
+        // Before doing the recompute, we **MUST** reset to uninitialized to avoid a race between someone setting this in ::CancelCollection and
+        // someone doing a recompute across a boundary.
+        //
+        InterlockedExchange(&m_maxCancellationDepth, -1);
+
+        long computedMaximumDepth = IsEntireContextCanceled() ? ENTIRE_CONTEXT_CANCELED : -1;
+
+        _TaskCollectionBase *pCollection = m_pExecutingCollection;
+        while (pCollection != NULL && pCollection != m_pRootCollection)
+        {
+            if ((pCollection->_IsStructured() && (static_cast<_StructuredTaskCollection *>(pCollection))->_IsMarkedForCancellation()) ||
+                (!pCollection->_IsStructured() && (static_cast<_TaskCollection *>(pCollection))->_IsMarkedForAbnormalExit()))
+            {
+                computedMaximumDepth = pCollection->_M_inliningDepth;
+                break;
+            }
+
+            pCollection = pCollection->_SafeGetParent();
+        }
+
+        long curMaxDepth = -1;
+
+        //
+        // Keep track of the maximum cancellation depth
+        //
+        for(;;)
+        {
+            if (curMaxDepth != -1 && computedMaximumDepth < curMaxDepth)
+                break;
+
+            long xchgDepth = InterlockedCompareExchange(&m_maxCancellationDepth, computedMaximumDepth, curMaxDepth);
+            if (xchgDepth == curMaxDepth)
+            {
+                break;
+            }
+
+            curMaxDepth = xchgDepth;
+        }
+    }
+
+    /// <summary>
+    ///     When a cancellation bubbles up to the collection being canceled, this function is called in order to stop propagation of
+    ///     the cancellation further up the work tree. This method is paired with CancelCollection.
+    /// </summary>
+    bool ContextBase::CancelCollectionComplete(int inliningDepth)
+    {
+        ASSERT(m_inlineCancellations > 0);
+
+        //
+        // Keep track of minimum/maximum cancellation depth.
+        //
+        InterlockedCompareExchange(&m_minCancellationDepth, -1, inliningDepth);
+        RecomputeMaximumCancellationDepth();
+
+        return (InterlockedDecrement(&m_inlineCancellations) == 0);
+    }
+
+    /// <summary>
+    ///     Send a context ETW event.
+    /// </summary>
+    void ContextBase::ThrowContextEvent(ConcRT_EventType eventType, UCHAR level, DWORD schedulerId, DWORD contextId)
+    {
+        if (g_pEtw != NULL)
+        {
+            CONCRT_TRACE_EVENT_HEADER_COMMON concrtHeader = {0};
+
+            concrtHeader.header.Size = sizeof concrtHeader;
+            concrtHeader.header.Flags = WNODE_FLAG_TRACED_GUID;
+            concrtHeader.header.Class.Type = (UCHAR)eventType;
+            concrtHeader.header.Class.Level = level;
+            concrtHeader.header.Guid = ContextEventGuid;
+
+            concrtHeader.SchedulerID = schedulerId;
+            concrtHeader.ContextID = contextId;
+
+            g_pEtw->Trace(g_ConcRTSessionHandle, &concrtHeader.header);
+        }
+    }
+
+    /// <summary>
+    ///     Enters a critical region of the scheduler. Calling this guarantees that the virtual processor on which this context lives
+    ///     is guaranteed to be stable throughout the critical region. For some context types, this is virtually a NOP.
+    ///     Note that critical regions suppress asynchronous blocking but not synchronous blocking.
+    /// </summary>
+    int ContextBase::EnterCriticalRegion()
+    {
+        return 0;
+    }
+
+    /// <summary>
+    ///     Exits a critical region of the scheduler.
+    /// </summary>
+    int ContextBase::ExitCriticalRegion()
+    {
+        return 0;
+    }
+
+    /// <summary>
+    ///     Enters a hyper-critical region of the scheduler. Calling this guarantees not only the conditions of a critical region but it
+    ///     guarantees that synchronous blocking is suppressed as well. This allows for lock sharing between the primary and hyper-critical
+    ///     regions running on UTs. No lock sharing can occur between the inside of this region type and the outside of this region type
+    ///     on a UT.
+    /// </summary>
+    int ContextBase::EnterHyperCriticalRegion()
+    {
+        return 0;
+    }
+
+    /// <summary>
+    ///     Exits a hyper-critical region of the scheduler.
+    /// </summary>
+    int ContextBase::ExitHyperCriticalRegion()
+    {
+        return 0;
+    }
+
+    /// <summary>
+    ///    Static version of EnterCriticalRegion.
+    /// </summary>
+    void ContextBase::StaticEnterCriticalRegion()
+    {
+        ContextBase *pContext = SchedulerBase::FastCurrentContext();
+        if (pContext != NULL)
+            pContext->EnterCriticalRegion();
+    }
+
+    /// <summary>
+    ///    Static version of EnterHyperCriticalRegion.
+    /// </summary>
+    void ContextBase::StaticEnterHyperCriticalRegion()
+    {
+        ContextBase *pContext = SchedulerBase::FastCurrentContext();
+        if (pContext != NULL)
+            pContext->EnterHyperCriticalRegion();
+    }
+
+    /// <summary>
+    ///    Static version of ExitCriticalRegion.
+    /// </summary>
+    void ContextBase::StaticExitCriticalRegion()
+    {
+        ContextBase *pContext = SchedulerBase::FastCurrentContext();
+        if (pContext != NULL)
+            pContext->ExitCriticalRegion();
+    }
+
+    /// <summary>
+    ///    Static version of ExitHyperCriticalRegion.
+    /// </summary>
+    void ContextBase::StaticExitHyperCriticalRegion()
+    {
+        ContextBase *pContext = SchedulerBase::FastCurrentContext();
+        if (pContext != NULL)
+            pContext->ExitHyperCriticalRegion();
+    }
+
+    /// <summary>
+    ///     Static version of GetCriticalRegionType.
+    /// </summary>
+    CriticalRegionType ContextBase::StaticGetCriticalRegionType()
+    {
+        ContextBase *pContext = SchedulerBase::FastCurrentContext();
+        if (pContext != NULL)
+            return pContext->GetCriticalRegionType();
+        return OutsideCriticalRegion;
+    }
+
+    /// <summary>
+    ///     Since critical region counts are turned off for thread schedulers, this method is used
+    ///     where the return value is expected to be true. For a thread scheduler, it always returns true.
+    /// </summary>
+    bool ContextBase::IsInsideCriticalRegion() const
+    {
+        return true;
+    }
+
+    /// <summary>
+    ///     Returns a bool which can be polled from the current location in lieu of calling is_current_task_group_canceling.
+    /// </summary>
+    _Beacon_reference *ContextBase::PushCancellationBeacon()
+    {
+        int inliningDepth = m_pExecutingCollection ? m_pExecutingCollection->_InliningDepth() : -1;
+
+        CancellationBeacon *pBeacon = m_cancellationBeacons.AcquirePushBeacon(inliningDepth);
+
+        //
+        // AcquirePushBeacon has a full fence to guard R/W ordering here.
+        //
+        if (IsEntireContextCanceled() || (m_minCancellationDepth != -1 && m_minCancellationDepth <= pBeacon->m_beaconDepth))
+            pBeacon->InternalSignal();
+
+        return &(pBeacon->m_beacon);
+    }
+
+    /// <summary>
+    ///     Releases the topmost bool acquired in RAII fashion from PushCancellationBeacon.
+    /// </summary>
+    void ContextBase::PopCancellationBeacon()
+    {
+        m_cancellationBeacons.ReleaseBeacon();
+    }
+
+    /// <summary>
+    ///     Flags any cancellation beacons that are inlined at or below the specified point.
+    /// </summary>
+    void ContextBase::FlagCancellationBeacons(int inliningDepth)
+    {
+        LONG snapSize = m_cancellationBeacons.BeaconCount();
+        for (LONG i = 0; i < snapSize; i++)
+        {
+            //
+            // The beacon list is guaranteed to exist. Further, because we do this during cancellation for inlined collections, we can
+            // never unpop and reuse a beacon for a lower depth until the cancellation is complete because of strict nesting on the
+            // beacon stack (RAII).
+            //
+            CancellationBeacon *pBeacon = m_cancellationBeacons[i];
+            if (pBeacon->m_beaconDepth >= inliningDepth)
+            {
+                //
+                // We have one interesting conundrum here. Everything from depth 0 -> inliningDepth is guaranteed to be stable. Anything from
+                // inliningDepth + 1 -> N can change. That change might include what cancellation tokens are active. This might, in fact, change
+                // whether a cancellation has truly happened or not.
+                //
+                // In order to solve this, two things will happen:
+                //
+                //     - Whoever observes a beacon signaled must do a further check to CONFIRM the cancellation.
+                //
+                //     - If there is a guarantee that the cancellation will not hit us in THIS call, we will not flag the beacon as a performance
+                //       optimization.
+                //
+                // This effectively means that we may see a **false positive** on the beacon but never a false negative due to the tokens. A false positive
+                // can be double checked. A false negative will never be flagged again and will lead to uncancellable trees!
+                //
+                int governingDepth = m_governingTokenDepth; // *MUST* be captured to be observationally consistent in the check below
+                if (governingDepth == -1 || governingDepth <= inliningDepth)
+                {
+                    pBeacon->InternalSignal();
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Called to determine if a confirmed cancellation on this context is hidden at the depth of the caller.
+    ///     A governing token that is not canceled could be protecting the task collection from cancellation from above.
+    ///     The token of the supplied task collection is used to veto an interruption. See comments in IsCancellationVisible
+    /// <summary>
+    bool ContextBase::TokenHidesCancellation(_TaskCollectionBase* pCurrentTaskCollection, bool hasOverrideToken) const
+    {
+        //
+        // An override token is used to determine visibility of cancellation at the end of _RunAndWait for structured
+        // and unstructured task collections. The governing token and cancellation depths apply to higher level task
+        // collections at this point, however, _RunAndWait should not interrupt if the token of pCurrentTaskCollection
+        // is not canceled, so that the token provides total isolation from parent cancellation.
+        //
+        if (hasOverrideToken)
+        {
+            _CancellationTokenState * pOverrideTokenState = pCurrentTaskCollection->_GetTokenState();
+            if (pOverrideTokenState == _CancellationTokenState::_None() || !pOverrideTokenState->_IsCanceled())
+            {
+                return true;
+            }
+        }
+        //
+        // Any token hides the propagation of implicit cancellation from above unless the token itself is EXPLICITLY canceled.
+        // Note, that m_maxCancellationDepth can be ENTIRE_CONTEXT_CANCELED, which is < -1, therefore we must check that the
+        // governing token depth is not -1.
+        //
+        if (m_maxCancellationDepth < m_governingTokenDepth && m_governingTokenDepth != -1)
+        {
+            ASSERT(m_pGoverningTokenState != NULL);
+            if (m_pGoverningTokenState == _CancellationTokenState::_None())
+            {
+                return true;
+            }
+            return (!m_pGoverningTokenState->_IsCanceled());
+        }
+        return false;
+    }
+
+    /// <summary>
+    ///     Called to determine whether a committed or pending cancellation on this context is visible at the level of the caller.
+    ///     NOTE: This method should only be called on the current context from _RunAndWait for the task collection supplied at an argument.
+    ///     The asserts below will check for that.
+    ///     The interruption points at the end of _RunAndWait must use the token of the task collection to override cancellation from
+    ///     above - i.e, even if the cancellation depth and governing token depth determine that an interruption point would've thrown
+    ///     an interruption exception, if there was an uncanceled token on this task collection, no interruption should take place.
+    ///     This allows total isolation from parent cancellation using cancellation tokens.
+    /// </summary>
+    bool ContextBase::IsCancellationVisible(_TaskCollectionBase* pCurrentTaskCollection, bool hasOverrideToken /* = false */) const
+    {
+        ASSERT(SchedulerBase::FastCurrentContext() == this && pCurrentTaskCollection->_M_pOwningContext == this);
+        ASSERT(m_pExecutingCollection == pCurrentTaskCollection || m_pExecutingCollection == pCurrentTaskCollection->_M_pParent);
+        ASSERT(HasAnyCancellation());
+
+        return ((HasInlineCancellation() && !TokenHidesCancellation(pCurrentTaskCollection, hasOverrideToken)) ||
+                    (HasPendingCancellation() && pCurrentTaskCollection->_WillInterruptForPendingCancel()));
+    }
+
+    /// <summary>
+    ///     Returns an indication as to whether a cancellation is occurring at the specified depth. The result here is normally only valid when
+    ///     called from the thread representing this context. There are times under the context chaining lock (stealers list) or from an indirect
+    ///     alias of a collection on this context, where this can be called safely **FOR CERTAIN DEPTHS** from another thread.
+    /// </summary>
+    /// <param name="depth">
+    ///     The depth at which to check for cancellation. If the method is called from a thread other than the one representing this context,
+    ///     the caller must guarantee that this context will not unwind past a task group or structured task group of inlining depth = 'depth'.
+    ///     If the caller has observed a collection inlined at 'depth' != -1 while holding the stealers lock on this context, or the caller
+    ///     is executing a chores on an indirect alias while the original task group is inlined, this guarantee is automatically provided.
+    /// </param>
+    bool ContextBase::IsCanceledAtDepth(_TaskCollectionBase *pStartingCollection, int depth)
+    {
+        ASSERT(pStartingCollection->_M_inliningDepth >= depth);
+        if (HasInlineCancellation() && m_minCancellationDepth <= depth)
+        {
+            //
+            // Normally, this would be an indication of a cancellation in progress. There may, however, be a cancellation token which stops
+            // us from observing it. Detecting this at arbitrary depth is more complex than detecting it at a current interruption point because
+            // we only track min/max on cancellation depth. Arbitrary depth requires us to walk back up the inlining tree until we find the token
+            // governing depth.
+            //
+            // If there is no token or all tokens are above the cancellation depth, clearly we do not need to do this.
+            //
+            if (m_governingTokenDepth == -1 || m_minCancellationDepth >= m_governingTokenDepth)
+                return true;
+
+            //
+            // If we are checking a cancellation beacon in strictly nested order, this is a simple bottom check.
+            //
+            if (pStartingCollection == m_pExecutingCollection && depth == m_pExecutingCollection->_M_inliningDepth)
+            {
+                if (m_pGoverningTokenState == _CancellationTokenState::_None())
+                    return false;
+
+                return m_pGoverningTokenState->_IsCanceled();
+            }
+
+            //
+            // At this point, we have exhausted every quick check since we can no longer rely on min/max. We need to walk the tree. Fortunately,
+            // this should not need to be done often.
+            //
+            _TaskCollectionBase *pCollection = pStartingCollection;
+            while (pCollection != NULL && pCollection != m_pRootCollection && pCollection->_M_inliningDepth != depth)
+            {
+                pCollection = pCollection->_SafeGetParent();
+            }
+
+            while (pCollection != NULL && pCollection != m_pRootCollection && pCollection->_GetTokenState() == NULL)
+            {
+                if ((pCollection->_IsStructured() && (static_cast<_StructuredTaskCollection *>(pCollection))->_IsMarkedForCancellation()) ||
+                    (!pCollection->_IsStructured() && (static_cast<_TaskCollection *>(pCollection))->_IsMarkedForAbnormalExit()))
+                {
+                    return true;
+                }
+                pCollection = pCollection->_SafeGetParent();
+            }
+
+            if (pCollection != NULL && pCollection != m_pRootCollection)
+            {
+                _CancellationTokenState *pGoverningTokenState = pCollection->_GetTokenState();
+                ASSERT(pGoverningTokenState != NULL);
+                if (pGoverningTokenState != _CancellationTokenState::_None())
+                {
+                    return pGoverningTokenState->_IsCanceled();
+                }
+            }
+        }
+        return false;
+    }
+
+    _Cancellation_beacon::_Cancellation_beacon()
+    {
+        ContextBase *pContext = SchedulerBase::CurrentContext();
+        _M_pRef = pContext->PushCancellationBeacon();
+    }
+
+    _Cancellation_beacon::~_Cancellation_beacon()
+    {
+        ContextBase *pContext = SchedulerBase::CurrentContext();
+        pContext->PopCancellationBeacon();
+    }
+
+    bool _Cancellation_beacon::_Confirm_cancel()
+    {
+        ContextBase *pContext = SchedulerBase::CurrentContext();
+        bool fCanceled =  pContext->ConfirmCancel(_M_pRef);
+        if (!fCanceled)
+        {
+            _Lower();
+        }
+        return fCanceled;
+    }
+
+    /// <summary>
+    ///     Return a reference to the ppltask inline schedule depth slot on current context
+    ///     The inline depth will be set to 0 when the context is first initialized,
+    ///     and the caller is responsible to maintain that depth.
+    /// </summary>
+    _CONCRTIMP size_t & __cdecl _StackGuard::_GetCurrentInlineDepth()
+    {
+        return SchedulerBase::CurrentContext()->m_asyncTaskCollectionInlineDepth;
+    }
+} // namespace details
+
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ContextBase.h

@@ -0,0 +1,1147 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ContextBase.h
+//
+// Header file containing the metaphor for an execution context/stack/thread.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+// Defines used for context blocking (m_blockedState):
+// * Possible blocked states
+#define CONTEXT_NOT_BLOCKED         0x0
+#define CONTEXT_BLOCKED             0x1
+#define CONTEXT_UMS_SYNC_BLOCKED    0x2
+#define CONTEXT_UMS_ASYNC_BLOCKED   0x4
+
+// * Useful bit-masks
+#define CONTEXT_SYNC_BLOCKED        (CONTEXT_BLOCKED | CONTEXT_UMS_SYNC_BLOCKED)
+#define CONTEXT_UMS_BLOCKED         (CONTEXT_UMS_SYNC_BLOCKED | CONTEXT_UMS_ASYNC_BLOCKED)
+
+#define ENTIRE_CONTEXT_CANCELED     -999
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Implements the base class for a ConcRT execution context.
+    /// </summary>
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class ContextBase : public Context
+    {
+    public:
+        //
+        // Public Methods
+        //
+
+        /// <summary>
+        ///     Constructor
+        /// </summary>
+        ContextBase(SchedulerBase *pScheduler, bool fIsExternal);
+
+        /// <summary>
+        ///     Returns a unique identifier to the context.
+        /// </summary>
+        virtual unsigned int GetId() const;
+
+        /// <summary>
+        ///     Returns an identifier to the virtual processor the context is currently executing on, if any.
+        /// </summary>
+        virtual unsigned int GetVirtualProcessorId() const =0;
+
+        /// <summary>
+        ///     Returns an identifier to the schedule group the context is currently working on, if any.
+        /// </summary>
+        virtual unsigned int GetScheduleGroupId() const;
+
+        /// <summary>
+        ///     Returns the reference count of the underlying schedule group, which is equivalent
+        ///     to the number of contexts performing work on the schedule group.
+        /// <summary>
+        unsigned int ScheduleGroupRefCount() const;
+
+        /// <summary>
+        ///     Causes the context to block, yielding the virtual processor to another context.
+        /// </summary>
+        virtual void Block() =0;
+
+        /// <summary>
+        ///     Unblocks the context and makes it runnable.
+        /// </summary>
+        virtual void Unblock() =0;
+
+        /// <summary>
+        ///     Determines whether or not the context is synchronously blocked at this given time.
+        /// </summary>
+        /// <returns>
+        ///     Whether context is in synchronous block state.
+        /// </returns>
+        virtual bool IsSynchronouslyBlocked() const =0;
+
+        /// <summary>
+        ///     Returns whether the context is blocked or not. Note that this definition of blocked is "blocked and requires
+        ///     eventual reexecution -- e.g.: finalization will call this during the sweep phase).
+        /// </summary>
+        bool IsBlocked() const
+        {
+            return (m_blockedState != CONTEXT_NOT_BLOCKED);
+        }
+
+        /// <summary>
+        ///     Yields execution to a different runnable context, and puts this context on a runnables collection.
+        ///     If no context is found to yield to, the context continues to run.
+        /// </summary>
+        virtual void Yield() =0;
+
+        /// <summary>
+        ///     Yields execution to a different runnable context, and puts this context on a runnables collection.
+        ///     If no context is found to yield to, the context continues to run.
+        ///
+        ///     This is intended for spin loops.
+        /// </summary>
+        virtual void SpinYield() =0;
+
+        /// <summary>
+        ///     See comments for Concurrency::Context::Oversubscribe.
+        /// </summary>
+        virtual void Oversubscribe(bool beginOversubscription) =0;
+
+        /// <summary>
+        ///     Cleans up the Context.
+        /// </summary>
+        void Cleanup();
+
+        /// <summary>
+        ///     Allocates a block of memory of the size specified.
+        /// </summary>
+        /// <param name="numBytes">
+        ///     Number of bytes to allocate.
+        /// </param>
+        /// <returns>
+        ///     A pointer to newly allocated memory.
+        /// </returns>
+        virtual void* Alloc(size_t numBytes) =0;
+
+        /// <summary>
+        ///     Frees a block of memory previously allocated by the Alloc API.
+        /// </summary>
+        /// <param name="pAllocation">
+        ///     A pointer to an allocation previously allocated by Alloc.
+        /// </param>
+        virtual void Free(void* pAllocation) =0;
+
+        /// <summary>
+        ///     Enters a critical region of the scheduler. Calling this guarantees that the virtual processor on which this context lives
+        ///     is guaranteed to be stable throughout the critical region. For some context types, this is virtually a NOP. For others
+        ///     (UMS), this makes it appear that blocking on the context actually blocks the UMS thread instead of triggering return to
+        ///     primary. Note that critical regions suppress asynchronous blocking but not synchronous blocking.
+        /// </summary>
+        virtual int EnterCriticalRegionHelper()
+        {
+            CONCRT_COREASSERT(Context::CurrentContext() == this);
+            return ++m_criticalRegionCount;
+        }
+
+        int EnterCriticalRegion();
+
+        /// <summary>
+        ///    Static version of EnterCriticalRegion.
+        /// </summary>
+        static void StaticEnterCriticalRegion();
+
+        /// <summary>
+        ///     Enters a hyper-critical region of the scheduler. Calling this guarantees not only the conditions of a critical region but it
+        ///     guarantees that synchronous blocking is suppressed as well. This allows for lock sharing between the primary and hyper-critical
+        ///     regions running on UTs. No lock sharing can occur between the inside of this region type and the outside of this region type
+        ///     on a UT.
+        /// </summary>
+        virtual int EnterHyperCriticalRegionHelper()
+        {
+            m_criticalRegionCount++;
+            return ++m_hyperCriticalRegionCount;
+        }
+
+        int EnterHyperCriticalRegion();
+
+        /// <summary>
+        ///    Static version of EnterHyperCriticalRegion.
+        /// </summary>
+        static void StaticEnterHyperCriticalRegion();
+
+        /// <summary>
+        ///     Exits a critical region of the scheduler.
+        /// </summary>
+        virtual int ExitCriticalRegionHelper()
+        {
+            CONCRT_COREASSERT(m_criticalRegionCount > 0);
+            CONCRT_COREASSERT(Context::CurrentContext() == this);
+            return --m_criticalRegionCount;
+        }
+
+        int ExitCriticalRegion();
+
+        /// <summary>
+        ///    Static version of ExitCriticalRegion.
+        /// </summary>
+        static void StaticExitCriticalRegion();
+
+        /// <summary>
+        ///     Exits a hyper-critical region of the scheduler.
+        /// </summary>
+        virtual int ExitHyperCriticalRegionHelper()
+        {
+            CONCRT_COREASSERT(m_hyperCriticalRegionCount > 0);
+            CONCRT_COREASSERT(m_criticalRegionCount > 0);
+            m_criticalRegionCount--;
+            return --m_hyperCriticalRegionCount;
+        }
+
+        int ExitHyperCriticalRegion();
+
+        /// <summary>
+        ///    Static version of ExitHyperCriticalRegion.
+        /// </summary>
+        static void StaticExitHyperCriticalRegion();
+
+        /// <summary>
+        ///     Checks if a context is in a critical region. This is only safe from either the current context or from a UMS primary which
+        ///     has woken due to a given context blocking.
+        /// </summary>
+        virtual CriticalRegionType GetCriticalRegionType() const
+        {
+            if (m_hyperCriticalRegionCount > 0)
+                return InsideHyperCriticalRegion;
+            if (m_criticalRegionCount > 0)
+                return InsideCriticalRegion;
+            return OutsideCriticalRegion;
+        }
+
+        /// <summary>
+        ///     Since critical region counts are turned off for thread schedulers, this method is used
+        ///     where the return value is expected to be true. For a thread scheduler, it always returns true.
+        ///     For a ums scheduler it returns (GetCriticalRegionType() != OutsideCriticalRegion).
+        ///     IsInsideContextLevelCriticalRegion only checks (ContextBase::GetCriticalRegionType() != OutsideCriticalRegion).
+        /// </summary>
+        bool IsInsideCriticalRegion() const;
+
+        /// <summary>
+        ///     Static version of GetCriticalRegionType.
+        /// </summary>
+        static CriticalRegionType StaticGetCriticalRegionType();
+
+        /// <summary>
+        ///     Set critical region counts to zero
+        /// </summary>
+        void ClearCriticalRegion()
+        {
+            m_hyperCriticalRegionCount = m_criticalRegionCount = 0;
+        }
+
+#if defined(_DEBUG)
+        /// <summary>
+        ///     Tells the context it's shutting down a virtual processor and normal lock validations don't apply.
+        /// </summary>
+        void SetShutdownValidations()
+        {
+            m_fShutdownValidations = true;
+        }
+
+        /// <summary>
+        ///     Re-enable normal lock validations
+        /// </summary>
+        void ClearShutdownValidations()
+        {
+            m_fShutdownValidations = false;
+        }
+
+        /// <summary>
+        ///     Returns whether or not the context is in a "shutting down a virtual processor" mode where normal lock validations don't apply.
+        /// </summary>
+        bool IsShutdownValidations() const
+        {
+            return m_fShutdownValidations;
+        }
+#endif // _DEBUG
+
+        /// <summary>
+        ///     Wrapper for m_pWorkQueue for use in unstructured task collections
+        ///     that performs delay construction as well as insertion into schedule group.
+        /// </summary>
+        WorkQueue *GetWorkQueue()
+        {
+            // want inlining
+            if (m_pWorkQueue == NULL)
+                CreateWorkQueue();
+            return m_pWorkQueue;
+        }
+
+        /// <summary>
+        ///     Wrapper for m_pWorkQueue for use in structured task collections
+        ///     that performs delay construction as well as insertion into schedule group.
+        /// </summary>
+        WorkQueue *GetStructuredWorkQueue()
+        {
+            // want inlining
+            if (m_pWorkQueue == NULL)
+                CreateStructuredWorkQueue();
+            return m_pWorkQueue;
+        }
+
+        /// <summary>
+        ///     Create a workqueue for use in unstructured task collections.
+        /// </summary>
+        void CreateWorkQueue();
+
+        /// <summary>
+        ///     Create a workqueue for use in structured task collections.
+        /// </summary>
+        void CreateStructuredWorkQueue();
+
+        /// <summary>
+        ///     Returns a unique identifier for the work queue associated with this context. Note that this should only be used
+        ///     for binding (e.g.: task collection binding)
+        /// </summary>
+        unsigned int GetWorkQueueIdentity()
+        {
+            return GetWorkQueue()->Id();
+        }
+
+        /// <summary>
+        ///     Pushes an unrealized chore onto the work stealing queue for structured parallelism.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to push onto the structured work stealing queue.
+        /// </param>
+        /// <param name="_PLocation">
+        ///     The location where the unrealized chore should execute.
+        /// </param>
+        void PushStructured(_UnrealizedChore *pChore, location *pLocation);
+
+        /// <summary>
+        ///     Pushes an unrealized chore onto the work stealing queue for structured parallelism.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to push onto the structured work stealing queue.
+        /// </param>
+        void PushStructured(_UnrealizedChore *pChore);
+
+        /// <summary>
+        ///     Pushes an unrealized chore onto the work stealing queue for unstructured parallelism.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to push onto the unstructured work stealing queue.
+        /// </param>
+        /// <param name="_PLocation">
+        ///     The location where the unrealized chore should execute.
+        /// </param>
+        int PushUnstructured(_UnrealizedChore *pChore, location *pLocation);
+
+        /// <summary>
+        ///     Pushes an unrealized chore onto the work stealing queue for unstructured parallelism.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to push onto the unstructured work stealing queue.
+        /// </param>
+        int PushUnstructured(_UnrealizedChore *pChore);
+
+        /// <summary>
+        ///     Sweeps the unstructured work stealing queue for items matching a predicate and potentially removes them
+        ///     based on the result of a callback.
+        /// </summary>
+        /// <param name="pPredicate">
+        ///     The predicate for things to call pSweepFn on.
+        /// </param>
+        /// <param name="pData">
+        ///     The data for the predicate callback
+        /// </param>
+        /// <param name="pSweepFn">
+        ///     The sweep function
+        /// </param>
+        void SweepUnstructured(WorkStealingQueue<_UnrealizedChore>::SweepPredicate pPredicate,
+                               void *pData,
+                               WorkStealingQueue<_UnrealizedChore>::SweepFunction pSweepFn
+                               );
+
+        /// <summary>
+        ///     Pops the topmost chore from the work stealing queue for structured parallelism. Failure
+        ///     to pop typically indicates stealing.
+        /// </summary>
+        /// <returns>
+        ///     An unrealized chore from the structured work stealing queue or NULL if none is present.
+        /// </returns>
+        _UnrealizedChore *PopStructured();
+
+        /// <summary>
+        ///     Attempts to pop the chore specified by a cookie value from the unstructured work stealing queue. Failure
+        ///     to pop typically indicates stealing.
+        /// </summary>
+        /// <param name="cookie">
+        ///     A cookie returned from PushUnstructured indicating the chore to attempt to pop from
+        ///     the unstructured work stealing queue.
+        /// </param>
+        /// <returns>
+        ///     The specified unrealized chore (as indicated by cookie) or NULL if it could not be popped from
+        ///     the work stealing queue.
+        /// </returns>
+        _UnrealizedChore *TryPopUnstructured(int cookie);
+
+        /// <summary>
+        ///     Returns the scheduler the specified context is associated with.
+        /// </summary>
+        SchedulerBase *GetScheduler() const;
+
+        /// <summary>
+        ///     Returns the schedule group the specified context is associated with.
+        /// </summary>
+        ScheduleGroupBase *GetScheduleGroup() const;
+
+        /// <summary>
+        ///     Returns the schedule group segment the specified context is associated with.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetScheduleGroupSegment() const;
+
+        /// <summary>
+        ///     Tells whether the context is an external context
+        /// </summary>
+        bool IsExternal() const { return m_fIsExternal; }
+
+        /// <summary>
+        ///     Gets the indirect alias.
+        /// </summary>
+        _TaskCollection *GetIndirectAlias() const;
+
+        /// <summary>
+        ///     Sets the indirect alias.
+        /// </summary>
+        void SetIndirectAlias(_TaskCollection *pAlias);
+
+        /// <summary>
+        ///     Returns whether a task collection or structured task collection executing on this context was canceled while it was inlined.
+        /// </summary>
+        bool HasInlineCancellation() const
+        {
+            return (m_inlineCancellations > 0);
+        }
+
+        /// <summary>
+        ///     Returns whether the entire context was canceled due to a steal.
+        /// </summary>
+        bool IsEntireContextCanceled() const
+        {
+            return (m_canceledContext != 0);
+        }
+
+        /// <summary>
+        ///     Called in order to indicate that a cancellation is happening for a structured task collection associated with this thread
+        ///     that has not been inlined yet.
+        /// </summary>
+        void PendingCancel()
+        {
+            InterlockedIncrement(&m_pendingCancellations);
+        }
+
+        /// <summary>
+        ///     Called when a pending cancel completes.
+        /// </summary>
+        void PendingCancelComplete()
+        {
+            ASSERT(m_pendingCancellations > 0);
+            InterlockedDecrement(&m_pendingCancellations);
+        }
+
+        /// <summary>
+        ///     Returns whether a structured task collection executing on this context was canceled before it was inlined.
+        /// </summary>
+        bool HasPendingCancellation() const
+        {
+            return (m_pendingCancellations > 0);
+        }
+
+        /// <summary>
+        ///     Returns whether there is any cancellation on the context (pending or inline)
+        /// </summary>
+        bool HasAnyCancellation() const
+        {
+            return (m_pendingCancellations + m_inlineCancellations > 0);
+        }
+
+        /// <summary>
+        ///     Called to determine if a confirmed cancellation on this context is hidden at the depth of the caller.
+        ///     A governing token that is not canceled could be protecting the task collection from cancellation from above.
+        /// <summary>
+        bool TokenHidesCancellation(_TaskCollectionBase* pCurrentTaskCollection, bool hasOverrideToken) const;
+
+        /// <summary>
+        ///     Called to determine whether a inline or pending cancellation on this context is visible to the caller.
+        /// </summary>
+        bool IsCancellationVisible(_TaskCollectionBase* pCurrentTaskCollection, bool hasOverrideToken = false) const;
+
+        /// <summary>
+        ///     Called in order to indicate that a collection executing on this context was canceled. This will often cause cancellation
+        ///     and unwinding of the entire context (up to the point where we get to the canceled collection).
+        /// </summary>
+        void CancelCollection(int inliningDepth);
+
+        /// <summary>
+        ///     Called in order to indicate that we're blowing away the entire context. It's stolen from a collection which was canceled.
+        /// </summary>
+        void CancelEntireContext()
+        {
+            InterlockedExchange(&m_canceledContext, TRUE);
+            CancelCollection(ENTIRE_CONTEXT_CANCELED);
+        }
+
+        /// <summary>
+        ///     When a cancellation bubbles up to the collection being canceled, this function is called in order to stop propagation of
+        ///     the cancellation further up the work tree.
+        /// </summary>
+        bool CancelCollectionComplete(int inliningDepth);
+
+        /// <summary>
+        ///     Completely clears the cancel count. This should be called when a root stolen chore completes on a context.
+        /// </summary>
+        void ClearCancel()
+        {
+            m_minCancellationDepth = -1;
+            m_maxCancellationDepth = -1;
+            m_inlineCancellations = 0;
+            m_canceledContext = 0;
+        }
+
+        /// <summary>
+        ///     Returns the task collection executing atop a stolen context.
+        /// </summary>
+        _TaskCollectionBase *GetRootCollection()
+        {
+            return m_pRootCollection;
+        }
+
+        /// <summary>
+        ///     Sets the task collection executing atop a stolen context. Note that this also sets the executing collection since the root
+        ///     collection is executing at the time it is set.
+        /// </summary>
+        void SetRootCollection(_TaskCollectionBase *pRootCollection)
+        {
+            m_pRootCollection = pRootCollection;
+            m_pExecutingCollection = pRootCollection;
+        }
+
+        /// <summary>
+        ///     Gets the task collection currently executing atop the context.
+        /// </summary>
+        _TaskCollectionBase *GetExecutingCollection()
+        {
+            return m_pExecutingCollection;
+        }
+
+        /// <summary>
+        ///     Sets the task collection currently executing atop the context.
+        /// </summary>
+        void SetExecutingCollection(_TaskCollectionBase *pExecutingCollection)
+        {
+            m_pExecutingCollection = pExecutingCollection;
+        }
+
+        /// <summary>
+        ///     Gets the cancellation token currently governing this context.
+        /// </summary>
+        _CancellationTokenState *GetGoverningTokenState()
+        {
+            return m_pGoverningTokenState;
+        }
+
+        /// <summary>
+        ///     Sets the cancellation token currently governing this context.
+        /// </summary>
+        void PushGoverningTokenState(_CancellationTokenState *pTokenState, int inliningDepth);
+
+        /// <summary>
+        ///     Reverts to the previously set cancellation token.
+        /// </summary>
+        void PopGoverningTokenState(_CancellationTokenState *pTokenState);
+
+        /// <summary>
+        ///     Returns an indication as to whether a cancellation is occurring at the specified depth. The result here is only valid when
+        ///     called from the thread representing this context.
+        /// </summary>
+        bool IsCanceledAtDepth(int depth)
+        {
+            return IsCanceledAtDepth(m_pExecutingCollection, depth);
+        }
+
+        /// <summary>
+        ///     Returns an indication as to whether a cancellation is occurring at the depth specified by the inlining depth of the given collection. This
+        ///     may ONLY be called while the context chaining (stealers) lock is held and only where it is known that there is a steal from
+        ///     pStartingCollection.
+        /// </summary>
+        bool IsCanceledAtDepth(_TaskCollectionBase *pStartingCollection)
+        {
+            return IsCanceledAtDepth(pStartingCollection, pStartingCollection->_M_inliningDepth);
+        }
+
+        /// <summary>
+        ///     Verifies that a cancellation beacon signal is really a cancellation for that beacon.
+        /// </summary>
+        bool ConfirmCancel(_Beacon_reference *pBeaconRef)
+        {
+            CancellationBeacon *pBeacon = CONTAINING_RECORD(pBeaconRef, CancellationBeacon, m_beacon);
+            return IsCanceledAtDepth(pBeacon->m_beaconDepth);
+        }
+
+        /// <summary>
+        ///     Places a reference on the context preventing it from being destroyed until such time as the stealer is added to the chain
+        ///     via AddStealer. Note that the operation of AddStealer should happen rapidly as it will *BLOCK* cleanup of the context.
+        /// </summary>
+        void ReferenceForCancellation();
+
+        /// <summary>
+        ///     Removes a reference on the context which was preventing it from being destroyed.
+        /// </summary>
+        void DereferenceForCancellation();
+
+        /// <summary>
+        ///     Adds a stealing context. Removes a reference.
+        /// </summary>
+        void AddStealer(ContextBase *pStealer, bool fDereferenceForCancellation);
+
+        /// <summary>
+        ///     Removes a stealing context.
+        /// </summary>
+        void RemoveStealer(ContextBase *pStealer);
+
+        /// <summary>
+        ///     Called by a stolen chore to flag the context as running a chore for which the steal is chained to a task collection instead
+        ///     of the context.
+        /// </summary>
+        void NotifyTaskCollectionChainedStealer()
+        {
+            m_fContextChainedStealer = false;
+        }
+
+        /// <summary>
+        ///     Returns whether the given context's steal is chained to the context (true) or some task collection (false)
+        /// </summary>
+        bool IsContextChainedStealer() const
+        {
+            return m_fContextChainedStealer;
+        }
+
+        /// <summary>
+        ///     Called on both internal and external contexts, either when the are put into an idle pool to
+        ///     be recycled, or when they are ready to be deleted. The API moves the contexts that are in
+        ///     the list of 'stealers' (used for cancellation) to lists in the task collections from which
+        ///     those contexts have stolen chores.
+        /// </summary>
+        void DetachStealers();
+
+        /// <summary>
+        ///     Gets an arbitrary alias out of the context's alias table.
+        /// </summary>
+        _TaskCollection *GetArbitraryAlias(_TaskCollection *pCollection)
+        {
+            Hash<_TaskCollection*, _TaskCollection*>::ListNode *pNode = m_aliasTable.Find(pCollection, NULL);
+            _TaskCollection *pAlias = (pNode != NULL ? pNode->m_value : NULL);
+            if (pAlias != NULL && pAlias->_IsStaleAlias())
+            {
+                m_aliasTable.Delete(pAlias->_OriginalCollection());
+                delete pAlias;
+                pAlias = NULL;
+            }
+            return pAlias;
+        }
+
+        /// <summary>
+        ///     Adds an arbitrary alias (direct or indirect) to the alias table.
+        /// </summary>
+        void AddArbitraryAlias(_TaskCollection *pOriginCollection, _TaskCollection *pAliasCollection)
+        {
+            SweepAliasTable();
+            m_aliasTable.Insert(pOriginCollection, pAliasCollection);
+        }
+
+        /// <summary>
+        ///     Sweeps the alias table for stale entries. Anything considered stale is deleted.
+        /// </summary>
+        void SweepAliasTable();
+
+        /// <summary>
+        ///     Clears the alias table.
+        /// </summary>
+        void ClearAliasTable();
+
+        /// <summary>
+        ///     Cancel everything stolen from pCollection outward from this context.
+        /// </summary>
+        void CancelStealers(_TaskCollectionBase *pCollection);
+
+        /// <summary>
+        ///     Returns the highest inlining depth (tree wise) of a canceled task collection. Note that it will return -1
+        ///     if there is no in-progress cancellation on the context.
+        /// </summary>
+        int MinimumCancellationDepth() const
+        {
+            //
+            // If the entire context is canceled, the minimum depth is reported to be zero so as to be less than all inlining depths
+            // for the purposes of checking cancellation. Note that even if the top collection has inlining depth of zero, it does not matter
+            // since it **IS** the top collection.
+            //
+            return IsEntireContextCanceled() ? 0 : m_minCancellationDepth;
+        }
+
+        // An enumerated type that tells the type of the underlying execution context.
+        enum ContextKind
+        {
+            ExternalContext,
+            ThreadContext,
+        };
+
+        /// <summary>
+        ///     Returns the type of context
+        /// </summary>
+        virtual ContextKind GetContextKind() const = 0;
+
+#if _DEBUG
+        // _DEBUG helper
+        virtual DWORD GetThreadId() const = 0;
+#endif
+
+        /// <summary>
+        ///     Returns a bool which can be polled from the current location in lieu of calling is_current_task_group_canceling.
+        /// </summary>
+        _Beacon_reference *PushCancellationBeacon();
+
+        /// <summary>
+        ///     Releases the topmost bool acquired in RAII fashion from PushCancellationBeacon.
+        /// </summary>
+        void PopCancellationBeacon();
+
+        /// <summary>
+        ///     Flags any cancellation beacons that are inlined at or below the specified point.
+        /// </summary>
+        void FlagCancellationBeacons(int inliningDepth);
+
+    protected:
+        class ScopedCriticalRegion
+        {
+        public:
+            ScopedCriticalRegion(ContextBase* pCB) : m_pCB(pCB)
+            {
+                m_pCB->EnterCriticalRegion();
+            }
+
+            ~ScopedCriticalRegion()
+            {
+                m_pCB->ExitCriticalRegion();
+            }
+
+        private:
+            const ScopedCriticalRegion& operator=(const ScopedCriticalRegion&); //no assignment operator
+            ContextBase* m_pCB;
+        };
+
+        //
+        // Protected data members
+        //
+
+        // Entry for freelist
+        SLIST_ENTRY m_slNext;
+
+        // Unique identifier
+        unsigned int m_id;
+
+        // Critical region counter.
+        DWORD m_criticalRegionCount;
+
+        // Hyper-critical region counter.
+        DWORD m_hyperCriticalRegionCount;
+
+        // Oversubscription count - the number of outstanding Oversubscribe(true) calls on this context.
+        DWORD m_oversubscribeCount;
+
+        // The schedule group segment that the context picked up work from
+        ScheduleGroupSegmentBase *m_pSegment;
+
+        // The scheduler instance the context belongs to.
+        SchedulerBase *m_pScheduler;
+
+        // Workqueue for unrealized chores.
+        WorkQueue *m_pWorkQueue;
+
+        // Link to implement the stack of parent contexts for nested schedulers.
+        ContextBase *m_pParentContext;
+
+        // Flag indicating whether the context is blocked.
+        volatile LONG m_blockedState;
+
+        // Memory fence to assist Block/Unblock.
+        volatile LONG m_contextSwitchingFence;
+
+        // Tracks the task collection from which this context stole (if it's a context executing a stolen chore).
+        _TaskCollectionBase *m_pRootCollection;
+
+        // Tracks the task collection currently executing (used to maintain parent/child relationships).
+        _TaskCollectionBase *m_pExecutingCollection;
+
+        // Tracks the current cancellation token (for optimization)
+        _CancellationTokenState *m_pGoverningTokenState;
+
+        // The inlining depth of the first construct on this stack to utilize the governing token
+        int m_governingTokenDepth;
+
+        // The depth of ppltask being inlining scheduled on this context.
+        size_t m_asyncTaskCollectionInlineDepth;
+
+        // The thread id for the thread backing the context.
+        DWORD m_threadId;
+
+        //
+        // Protected methods
+        //
+
+        /// <summary>
+        ///     Clean up the work queue for this Context.
+        /// </summary>
+        void ReleaseWorkQueue();
+
+        /// <summary>
+        ///     Sets the 'this' context into the tls slot as the current context. This is used by internal contexts in
+        ///     their dispatch loops.
+        /// </summary>
+        void SetAsCurrentTls();
+
+        ///<summary>Send a context ETW event</summary>
+        void TraceContextEvent(ConcRT_EventType eventType, UCHAR level, DWORD schedulerId, DWORD contextId)
+        {
+            if (g_TraceInfo._IsEnabled(level, ContextEventFlag))
+                ThrowContextEvent(eventType, level, schedulerId, contextId);
+        }
+
+        static void ThrowContextEvent(ConcRT_EventType eventType, UCHAR level, DWORD schedulerId, DWORD contextId);
+
+    private:
+
+        //
+        // Friend declarations
+        //
+        friend class SchedulerBase;
+        friend class ThreadScheduler;
+        friend class InternalContextBase;
+        friend class SchedulingRing;
+        friend class VirtualProcessor;
+        friend class ScheduleGroupBase;
+        friend class ScheduleGroupSegmentBase;
+        friend class ScheduleGroup;
+        friend class FairScheduleGroup;
+        friend class CacheLocalScheduleGroup;
+        friend class _UnrealizedChore;
+        friend class _TaskCollection;
+        friend class _StructuredTaskCollection;
+        friend class _StackGuard;
+        template <class T> friend class LockFreeStack;
+
+        //
+        // Private data
+        //
+
+        // Used in finalization to distinguish between blocked and free-list contexts
+        LONG m_sweeperMarker;
+
+        // Flag indicating context kind.
+        bool m_fIsExternal;
+
+        // Keeps track as to whether this context is chained to a context (true) or a schedule group (false) for the purposes of stealing/cancellation.
+        bool m_fContextChainedStealer;
+
+        // Indicates that normal lock validations should not be performed -- the context is shutting down a virtual processor.
+        bool m_fShutdownValidations;
+
+        // Tracks all contexts which stole from any collection on *this* context.
+        SafeRWList<ListEntry> m_stealers;
+        // Link for contexts added to m_stealers
+        ListEntry m_stealChain;
+
+        // Reference count of things waiting to be added to the steal chain of this context.
+        volatile LONG m_cancellationRefCount;
+
+        // Depth is inversely proportion to height in the description of min and max depths. If inlined tg A at depth 0 inlines tg B,
+        //    tg A is considered to be higher than tg B on that context.
+        // The inlining depth of the highest canceled task collection.
+        volatile LONG m_minCancellationDepth;
+        // The inlining depth of the lowest canceled task collection.
+        volatile LONG m_maxCancellationDepth;
+
+        // The number of task collections and structured task collections running on this context that were canceled when they were inlined
+        volatile LONG m_inlineCancellations;
+        // An indication that the context was shot down as it stole from a canceled collection.
+        volatile LONG m_canceledContext;
+        // An indication that there is a pending cancellation of a structured collection on this thread (the collection was canceled before it
+        // was inlined).
+        volatile LONG m_pendingCancellations;
+        // The indirect alias for this context. This allows an unstructured task collection to carry into a stolen chore and be
+        // utilized there without any cross threaded semantics within the task collection.
+        _TaskCollection *m_pIndirectAlias;
+        // The table of aliases for this context. This allows transitive indirect aliases as well as direct aliases (which
+        // are not presently implemented).
+        Hash<_TaskCollection*, _TaskCollection*> m_aliasTable;
+
+        //
+        // A cancellation beacon is a flag that the runtime signals when cancellation occurs. It allows hot code paths to poll
+        // for cancellation in an inlinable way. Parallel for, for instance, gets huge performance wins utilizing this mechanism over
+        // a non-inlinable call to is_current_task_group_canceling.
+        //
+        // Beacons also allow manual raising from the outside for various things in conjunction with cancellation.
+        //
+        struct CancellationBeacon
+        {
+            _Beacon_reference m_beacon;
+            int m_beaconDepth;
+
+            void Raise()
+            {
+                InterlockedIncrement(&m_beacon._M_signals);
+            }
+
+            void Lower()
+            {
+                InterlockedDecrement(&m_beacon._M_signals);
+            }
+
+            void InternalSignal()
+            {
+                Raise();
+            }
+        };
+
+        //
+        // In order for the cancellation beacon mechanism to work, we must manage all storage for beacons. A cancellation beacon may disappear
+        // asynchronously with respect to cancellation walking the stack of the thread holding the beacon. Once we hand out a beacon flag, we must
+        // NOT allow that memory location to become invalid until the runtime owns the base of the stack again.
+        //
+        // Because of the rules and RAII idiom around this, it does not matter if we hand out the same beacon to a new owner on the same thread.
+        //
+        // The CancellationBeaconStack manages a growing stack of beacons without reallocations.
+        //
+        class CancellationBeaconStack
+        {
+        private:
+
+            // Defines the number of segments in the index
+            static const LONG NODE_INDEX_SIZE = 4;
+
+            // Defines how large (and the bitmasks) each segment is.
+            static const LONG BEACON_NODE_SIZE = 16;
+            static const LONG BEACON_NODE_MASK = 0xFFFFFFF0;
+            static const LONG BEACON_NODE_ITEM_MASK = 0xF;
+            static const LONG BEACON_NODE_SHIFT = 4;
+
+            //
+            // A segment of the stack. Once allocated, data can never move (even after being released).
+            //
+            struct CancellationBeaconNode
+            {
+                CancellationBeaconNode() : m_pNext(NULL)
+                {
+                    m_pBeacons = _concrt_new CancellationBeacon[BEACON_NODE_SIZE];
+                }
+
+                ~CancellationBeaconNode()
+                {
+                    delete[] m_pBeacons;
+                }
+
+                CancellationBeacon *m_pBeacons;
+                CancellationBeaconNode *m_pNext;
+            };
+
+            // The stack pointer
+            LONG m_beaconDepth;
+
+            // The size of the stack
+            LONG m_size;
+
+            // The index to stack segments
+            CancellationBeaconNode **m_pNodeIndex;
+
+            /// <summary>
+            ///     Increases the size of the beacon stack without moving any memory associated with beacons that have been handed
+            ///     out.
+            /// </summary>
+            void Grow()
+            {
+                CancellationBeaconNode *pNewNode;
+                CancellationBeaconNode *pPrevNode = NULL;
+
+                LONG idx = (m_size & BEACON_NODE_MASK) >> BEACON_NODE_SHIFT;
+                if (idx < NODE_INDEX_SIZE)
+                {
+                    if (idx > 0)
+                        pPrevNode = m_pNodeIndex[idx - 1];
+
+                    pNewNode = m_pNodeIndex[idx] = _concrt_new CancellationBeaconNode;
+                }
+                else
+                {
+                    pNewNode = pPrevNode = m_pNodeIndex[NODE_INDEX_SIZE - 1];
+
+                    idx -= (NODE_INDEX_SIZE - 1);
+                    while (idx--)
+                    {
+                        pPrevNode = pNewNode;
+                        pNewNode = pNewNode->m_pNext;
+                    }
+
+                    ASSERT(pNewNode == NULL);
+                    pNewNode = _concrt_new CancellationBeaconNode;
+                }
+
+                if (pPrevNode)
+                    pPrevNode->m_pNext = pNewNode;
+
+                m_size += BEACON_NODE_SIZE;
+
+            }
+
+        public:
+
+            /// <summary>
+            ///     Creates a new cancellation beacon stack.
+            /// </summary>
+            CancellationBeaconStack() :
+                m_beaconDepth(0),
+                m_size(0)
+            {
+                m_pNodeIndex = _concrt_new CancellationBeaconNode* [NODE_INDEX_SIZE];
+            }
+
+            /// <summary>
+            ///     Destroys a cancellation beacon stack.
+            /// </summary>
+            ~CancellationBeaconStack()
+            {
+                if (m_size > 0)
+                {
+                    CancellationBeaconNode *pNode = m_pNodeIndex[0];
+                    while (pNode != NULL)
+                    {
+                        CancellationBeaconNode *pNext = pNode->m_pNext;
+                        delete pNode;
+                        pNode = pNext;
+                    }
+                }
+
+                delete [] m_pNodeIndex;
+            }
+
+            /// <summary>
+            ///     Acquires memory for a new cancellation beacon and initializes it for the specified inlining depth.
+            /// </summary>
+            CancellationBeacon *AcquirePushBeacon(int inliningDepth)
+            {
+                if (m_beaconDepth >= m_size)
+                    Grow();
+
+                CancellationBeacon *pBeacon = operator[](m_beaconDepth);
+                pBeacon->m_beacon._M_signals = 0;
+                pBeacon->m_beaconDepth = inliningDepth;
+                m_beaconDepth++;
+
+                //
+                // Force a full fence here for any R/W dependencies between the cancellation thread reading the beacon stack and us reading
+                // the cancellation state later once the beacon is acquired.
+                //
+                MemoryBarrier();
+
+                return pBeacon;
+            }
+
+            /// <summary>
+            ///     Releases the topmost cancellation beacon. The beacon can be handed out
+            /// </summary>
+            void ReleaseBeacon()
+            {
+                ASSERT(m_beaconDepth > 0);
+                m_beaconDepth--;
+            }
+
+            /// <summary>
+            ///     Returns a view of the number of beacons.
+            /// </summary>
+            LONG BeaconCount() const
+            {
+                return m_beaconDepth;
+            }
+
+            /// <summary>
+            ///     Returns the cancellation beacon specified as specified by the supplied index. Note that the index must be within
+            ///     the bounds of BeaconCount when used externally and m_size when used internally.
+            /// </summary>
+            CancellationBeacon *operator[](LONG idx)
+            {
+                CancellationBeaconNode *pNode = NULL;
+
+                LONG nIdx = (idx & BEACON_NODE_MASK) >> BEACON_NODE_SHIFT;
+                if (nIdx < NODE_INDEX_SIZE)
+                {
+                    pNode = m_pNodeIndex[nIdx];
+                }
+                else
+                {
+                    pNode = m_pNodeIndex[NODE_INDEX_SIZE - 1];
+                    nIdx -= (NODE_INDEX_SIZE - 1);
+                    while(nIdx--)
+                    {
+                        pNode = pNode->m_pNext;
+                    }
+                }
+
+                return &(pNode->m_pBeacons[idx & BEACON_NODE_ITEM_MASK]);
+            }
+        };
+
+        CancellationBeaconStack m_cancellationBeacons;
+
+        //
+        // Private member functions
+        //
+
+        /// <summary>
+        ///     When schedulers are nested on the same stack context, the nested scheduler creates a new external context that overrides
+        ///     the previous context. PopContextFromTls will restore the previous context by setting the TLS value appropriately.
+        /// </summary>
+        ContextBase* PopContextFromTls();
+
+        /// <summary>
+        ///     When schedulers are nested on the same stack context, the nested scheduler creates a new external context that overrides
+        ///     the previous context. PushContextToTls will remember the parent context and set the new context into TLS.
+        /// </summary>
+        void PushContextToTls(ContextBase* pParentContext);
+
+        /// <summary>
+        ///     Context TLS is cleared during nesting on internal contexts before the external context TLS is correctly setup. If not,
+        ///     code that executes between the clear and setting the new TLS could get confused.
+        /// </summary>
+        void ClearContextTls();
+
+        /// <summary>
+        ///     Recomputes the maximum depth of cancellation after a canceled task group clears its cancellation flag.
+        /// </summary>
+        void RecomputeMaximumCancellationDepth();
+
+        /// <summary>
+        ///     Returns an indication as to whether a cancellation is occurring at the specified depth. The result here is normally only valid when
+        ///     called from the thread representing this context. There are times under the context chaining lock (stealers list) where this can be
+        ///     called safely **FOR CERTAIN DEPTHS** from another thread. This variant should never be called directly. Always utilize one of the
+        ///     other overloads.
+        /// </summary>
+        bool IsCanceledAtDepth(_TaskCollectionBase *pStartingCollection, int depth);
+    };
+#pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/CurrentScheduler.cpp

@@ -0,0 +1,236 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// CurrentScheduler.cpp
+//
+// Implementation of static scheduler APIs for CurrentScheduler::
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+/// <returns>
+///     Returns a unique identifier for the current scheduler.  Returns -1 if no current scheduler exists.
+/// </returns>
+unsigned int CurrentScheduler::Id()
+{
+    const SchedulerBase *pScheduler = SchedulerBase::SafeFastCurrentScheduler();
+    return pScheduler != NULL ? pScheduler->Id() : UINT_MAX;
+}
+
+/// <returns>
+///     Returns a current number of virtual processors for the current scheduler. Returns -1 if no current scheduler exists.
+///     No error state.
+/// </returns>
+unsigned int CurrentScheduler::GetNumberOfVirtualProcessors()
+{
+    const SchedulerBase *pScheduler = SchedulerBase::SafeFastCurrentScheduler();
+    return pScheduler != NULL ? pScheduler->GetNumberOfVirtualProcessors() : UINT_MAX;
+}
+
+/// <returns>
+///     Returns a copy of the policy the current scheduler is using.  Returns NULL if no current
+///     scheduler exists.
+/// </returns>
+SchedulerPolicy CurrentScheduler::GetPolicy()
+{
+    const SchedulerBase *pScheduler = SchedulerBase::CurrentScheduler();
+    return pScheduler->GetPolicy();
+}
+
+/// <summary>
+///     Returns a reference to the scheduler instance in TLS storage (viz., the current scheduler).
+///     If one does not exist, the default scheduler for the process is attached to the calling thread and returned --
+///     if the default scheduler does not exist it is created
+/// </summary>
+/// <returns>
+///     The TLS storage for the current scheduler is returned.
+/// </returns>
+Scheduler* CurrentScheduler::Get()
+{
+    return SchedulerBase::CurrentScheduler();
+}
+
+/// <summary>
+///     The normal scheduler factory. (Implicitly calls Scheduler::Attach on the internally represented scheduler instance.)
+///     The created scheduler will become the current scheduler for the current context (if it is an OS context it will be
+///     inducted to a ConcRT context).  To shutdown such a scheduler, Detach needs to be called. Any extra Reference calls
+///     must be matched with Release for shutdown to commence.
+/// </summary>
+/// <param name="pPolicy">
+///     [in] A const pointer to the scheduler policy (See Scheduler Policy API)
+/// </param>
+void CurrentScheduler::Create(const SchedulerPolicy& policy)
+{
+    SchedulerBase *pScheduler = SchedulerBase::Create(policy);
+    pScheduler->Attach();
+}
+
+/// <summary>
+///     Detaches the current scheduler from the calling thread and restores the previously attached scheduler as the current
+///     scheduler. Implicitly calls Release. After this function is called, the calling thread is then managed by the scheduler
+///     that was previously activated via Create() or Attach().
+/// </summary>
+void CurrentScheduler::Detach()
+{
+    SchedulerBase* pScheduler = SchedulerBase::SafeFastCurrentScheduler();
+
+    if (pScheduler != NULL)
+    {
+        return pScheduler->Detach();
+    }
+    else
+    {
+        throw scheduler_not_attached();
+    }
+}
+
+/// <summary>
+///     Causes the OS event object 'shutdownEvent' to be set when the scheduler shuts down and destroys itself.
+/// </summary>
+/// <param name="shutdownEvent">
+///     [in] A valid event object
+/// </param>
+void CurrentScheduler::RegisterShutdownEvent(HANDLE shutdownEvent)
+{
+    SchedulerBase* pScheduler = SchedulerBase::SafeFastCurrentScheduler();
+
+    if (pScheduler != NULL)
+    {
+        return pScheduler->RegisterShutdownEvent(shutdownEvent);
+    }
+    else
+    {
+        throw scheduler_not_attached();
+    }
+}
+
+/// <summary>
+///     Create a schedule group within the current scheduler.
+/// </summary>
+ScheduleGroup* CurrentScheduler::CreateScheduleGroup()
+{
+    return SchedulerBase::CurrentScheduler()->CreateScheduleGroup();
+}
+
+/// <summary>
+///     Creates a new schedule group within the scheduler associated with the calling context.  Tasks scheduled within the newly created
+///     schedule group will be biased towards executing at the specified location.
+/// </summary>
+/// <param name="_Placement">
+///     A reference to a location where the tasks within the schedule group will biased towards executing at.
+/// </param>
+/// <returns>
+///     A pointer to the newly created schedule group.  This <c>ScheduleGroup</c> object has an initial reference count placed on it.
+/// </returns>
+/// <remarks>
+///     This method will result in the process' default scheduler being created and/or attached to the calling context if there is no
+///     scheduler currently associated with the calling context.
+///     <para>You must invoke the <see cref="ScheduleGroup::Release Method">Release</see> method on a schedule group when you are
+///     done scheduling work to it. The scheduler will destroy the schedule group when all work queued to it has completed.</para>
+///     <para>Note that if you explicitly created this scheduler, you must release all references to schedule groups within it, before
+///     you release your reference on the scheduler, via detaching the current context from it.</para>
+/// </remarks>
+/// <seealso cref="ScheduleGroup Class"/>
+/// <seealso cref="ScheduleGroup::Release Method"/>
+/// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+/// <seealso cref="location Class"/>
+ScheduleGroup* CurrentScheduler::CreateScheduleGroup(location& placement)
+{
+    return SchedulerBase::CurrentScheduler()->CreateScheduleGroup(placement);
+}
+
+/// <summary>
+///     Create a light-weight schedule within the current scheduler in an implementation dependent schedule group.
+/// </summary>
+/// <param name="proc">
+///     [in] A pointer to the main function of a task.
+/// </param>
+/// <param name="data">
+///     [in] A void pointer to the data that will be passed in to the task.
+/// <param>
+_Use_decl_annotations_
+void CurrentScheduler::ScheduleTask(TaskProc proc, void *data)
+{
+    SchedulerBase::CurrentScheduler()->ScheduleTask(proc, data);
+}
+
+/// <summary>
+///     Schedules a light-weight task within the scheduler associated with the calling context.  The light-weight task will be placed
+///     within a schedule group of the runtime's choosing.  It will also be biased towards executing at the specified location.
+/// </summary>
+/// <param name="proc">
+///     A pointer to the function to execute to perform the body of the light-weight task.
+/// </param>
+/// <param name="data">
+///     A void pointer to the data that will be passed as a parameter to the body of the task.
+/// </param>
+/// <param name="placement">
+///     A reference to a location where the light-weight task will be biased towards executing at.
+/// </param>
+/// <remarks>
+///     This method will result in the process' default scheduler being created and/or attached to the calling context if there is no
+///     scheduler currently associated with the calling context.
+/// </remarks>
+/// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+/// <seealso cref="ScheduleGroup Class"/>
+/// <seealso cref="location Class"/>
+_Use_decl_annotations_
+void CurrentScheduler::ScheduleTask(TaskProc proc, void * data, location& placement)
+{
+    SchedulerBase::CurrentScheduler()->ScheduleTask(proc, data, placement);
+}
+
+/// <summary>
+///     Determines whether a given location is available on the current scheduler.
+/// </summary>
+/// <param name="_Placement">
+///     A reference to the location to query the current scheduler about.
+/// </param>
+/// <returns>
+///     An indication of whether or not the location specified by the <paramref name="_Placement"/> argument is available on the current
+///     scheduler.
+/// </returns>
+/// <remarks>
+///     This method will not result in scheduler attachment if the calling context is not already associated with a scheduler.
+///     <para>Note that the return value is an instantaneous sampling of whether the given location is available.  In the presence of multiple
+///     schedulers, dynamic resource management may add or take away resources from schedulers at any point.  Should this happen, the given
+///     location may change availability.</para>
+/// </remarks>
+/**/
+bool CurrentScheduler::IsAvailableLocation(const location& _Placement)
+{
+    const SchedulerBase *pScheduler = SchedulerBase::SafeFastCurrentScheduler();
+    return pScheduler != NULL ? pScheduler->IsAvailableLocation(_Placement) : false;
+}
+
+namespace details
+{
+    void _CurrentScheduler::_ScheduleTask(TaskProc _Proc, void * _Data)
+    {
+        SchedulerBase::CurrentScheduler()->ScheduleTask(_Proc, _Data);
+    }
+
+    unsigned int _CurrentScheduler::_Id()
+    {
+        return CurrentScheduler::Id();
+    }
+
+    unsigned int _CurrentScheduler::_GetNumberOfVirtualProcessors()
+    {
+        return SchedulerBase::CurrentScheduler()->GetNumberOfVirtualProcessors();
+    }
+
+    _Scheduler _CurrentScheduler::_Get()
+    {
+        return _Scheduler(SchedulerBase::CurrentScheduler());
+    }
+} // namespace details
+
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Exceptions.cpp

@@ -0,0 +1,554 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Exceptions.cpp
+//
+// Implementation for concurrency runtime exceptions.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+//
+// scheduler_resource_allocation_error
+//
+
+/// <summary>
+///     Construct a scheduler_resource_allocation_error exception with a message and an error code
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+/// <param name="hresult">
+///     HRESULT of error that caused this exception
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP scheduler_resource_allocation_error::scheduler_resource_allocation_error(const char* message, HRESULT hresult) noexcept
+    : exception(message), _Hresult(hresult)
+{ }
+
+/// <summary>
+///     Construct a scheduler_resource_allocation_error exception with an error code
+/// </summary>
+/// <param name="hresult">
+///     HRESULT of error that caused this exception
+/// </param>
+_CONCRTIMP scheduler_resource_allocation_error::scheduler_resource_allocation_error(HRESULT hresult) noexcept
+    : exception(), _Hresult(hresult)
+{
+}
+
+/// <summary>
+///     Get the error code that caused this exception
+/// </summary>
+///<returns>HRESULT of error that caused the exception</returns>
+_CONCRTIMP HRESULT scheduler_resource_allocation_error::get_error_code() const noexcept
+{
+    return _Hresult;
+}
+
+//
+// scheduler_worker_creation_error
+//
+
+/// <summary>
+///     Constructs a <c>scheduler_worker_creation_error</c> object.
+/// </summary>
+/// <param name="_Message">
+///     A descriptive message of the error.
+/// </param>
+/// <param name="_Hresult">
+///     The <c>HRESULT</c> value of the error that caused the exception.
+/// </param>
+/**/
+_Use_decl_annotations_
+_CONCRTIMP scheduler_worker_creation_error::scheduler_worker_creation_error(const char * message, HRESULT hresult) noexcept
+    : scheduler_resource_allocation_error(message, hresult)
+{ }
+
+/// <summary>
+///     Constructs a <c>scheduler_worker_creation_error</c> object.
+/// </summary>
+/// <param name="_Hresult">
+///     The <c>HRESULT</c> value of the error that caused the exception.
+/// </param>
+/**/
+_CONCRTIMP scheduler_worker_creation_error::scheduler_worker_creation_error(HRESULT hresult) noexcept
+    : scheduler_resource_allocation_error(hresult)
+{ }
+
+//
+// unsupported_os -- exception thrown whenever an unsupported OS is used
+//
+
+/// <summary>
+///     Construct a unsupported_os exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP unsupported_os::unsupported_os(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a unsupported_os exception
+/// </summary>
+_CONCRTIMP unsupported_os::unsupported_os() noexcept
+    : exception()
+{
+}
+
+//
+// scheduler_not_attached
+//
+
+/// <summary>
+///     Construct a scheduler_not_attached exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP scheduler_not_attached::scheduler_not_attached(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a scheduler_not_attached exception
+/// </summary>
+_CONCRTIMP scheduler_not_attached::scheduler_not_attached() noexcept
+    : exception()
+{
+}
+
+//
+// improper_scheduler_attach
+//
+
+/// <summary>
+///     Construct a improper_scheduler_attach exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP improper_scheduler_attach::improper_scheduler_attach(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a improper_scheduler_attach exception
+/// </summary>
+_CONCRTIMP improper_scheduler_attach::improper_scheduler_attach() noexcept
+    : exception()
+{
+}
+
+//
+// improper_scheduler_detach
+//
+
+/// <summary>
+///     Construct a improper_scheduler_detach exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP improper_scheduler_detach::improper_scheduler_detach(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a improper_scheduler_detach exception
+/// </summary>
+_CONCRTIMP improper_scheduler_detach::improper_scheduler_detach() noexcept
+    : exception()
+{
+}
+
+//
+// improper_scheduler_reference
+//
+
+/// <summary>
+///     Construct a improper_scheduler_reference exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP improper_scheduler_reference::improper_scheduler_reference(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a improper_scheduler_reference exception
+/// </summary>
+_CONCRTIMP improper_scheduler_reference::improper_scheduler_reference() noexcept
+    : exception()
+{
+}
+
+//
+// default_scheduler_exists
+//
+
+/// <summary>
+///     Construct a default_scheduler_exists exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP default_scheduler_exists::default_scheduler_exists(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a default_scheduler_exists exception
+/// </summary>
+_CONCRTIMP default_scheduler_exists::default_scheduler_exists() noexcept
+    : exception()
+{
+}
+
+//
+// context_unblock_unbalanced
+//
+
+/// <summary>
+///     Construct a context_unblock_unbalanced exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP context_unblock_unbalanced::context_unblock_unbalanced(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a context_unblock_unbalanced exception
+/// </summary>
+_CONCRTIMP context_unblock_unbalanced::context_unblock_unbalanced() noexcept
+    : exception()
+{
+}
+
+//
+// context_self_unblock
+//
+
+/// <summary>
+///     Construct a context_self_unblock exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP context_self_unblock::context_self_unblock(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a context_unblock_unbalanced exception
+/// </summary>
+_CONCRTIMP context_self_unblock::context_self_unblock() noexcept
+    : exception()
+{
+}
+
+//
+// missing_wait -- Exception thrown whenever a task collection is destructed without being waited upon and still contains work
+//
+
+/// <summary>
+///     Construct a missing_wait exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP missing_wait::missing_wait(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a missing_wait exception
+/// </summary>
+_CONCRTIMP missing_wait::missing_wait() noexcept
+    : exception()
+{
+}
+
+//
+// bad_target -- Exception thrown whenever a messaging block is given a bad target pointer
+//
+
+/// <summary>
+///     Construct a bad_target exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP bad_target::bad_target(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a bad_target exception
+/// </summary>
+_CONCRTIMP bad_target::bad_target() noexcept
+    : exception()
+{
+}
+
+//
+// message_not_found -- Exception thrown whenever a messaging block is unable to find a requested message
+//
+
+/// <summary>
+///     Construct a message_not_found exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP message_not_found::message_not_found(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a message_not_found exception
+/// </summary>
+_CONCRTIMP message_not_found::message_not_found() noexcept
+    : exception()
+{
+}
+
+//
+// invalid_link_target -- Exception thrown whenever a messaging block tries to link a target twice
+// when it should only occur once
+//
+
+/// <summary>
+///     Construct a invalid_link_target exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_link_target::invalid_link_target(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a message_not_found exception
+/// </summary>
+_CONCRTIMP invalid_link_target::invalid_link_target() noexcept
+    : exception()
+{
+}
+
+//
+// invalid_scheduler_policy_key -- Exception thrown whenever a policy key is invalid
+//
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_key exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_scheduler_policy_key::invalid_scheduler_policy_key(const char* message) noexcept
+    : exception(message)
+{
+}
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_key exception
+/// </summary>
+_CONCRTIMP invalid_scheduler_policy_key::invalid_scheduler_policy_key() noexcept
+    : exception()
+{
+}
+
+//
+// invalid_scheduler_policy_value -- Exception thrown whenever a policy value is invalid
+//
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_value exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_scheduler_policy_value::invalid_scheduler_policy_value(const char* message) noexcept
+    : exception(message)
+{
+}
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_value exception
+/// </summary>
+_CONCRTIMP invalid_scheduler_policy_value::invalid_scheduler_policy_value() noexcept
+    : exception()
+{
+}
+
+//
+// invalid_scheduler_policy_thread_specification -- Exception thrown whenever a combination of thread specifications are invalid
+//
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_thread_specification exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_scheduler_policy_thread_specification::invalid_scheduler_policy_thread_specification(const char* message) noexcept
+    : exception(message)
+{
+}
+
+/// <summary>
+///     Construct a invalid_scheduler_policy_thread_specification exception
+/// </summary>
+_CONCRTIMP invalid_scheduler_policy_thread_specification::invalid_scheduler_policy_thread_specification() noexcept
+    : exception()
+{
+}
+
+//
+// nested_scheduler_missing_detach -- Exception thrown when the runtime can detect that
+// a Detach() was missing for a nested scheduler.
+//
+
+/// <summary>
+///     Construct an nested_scheduler_missing_detach exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP nested_scheduler_missing_detach::nested_scheduler_missing_detach(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct an nested_scheduler_missing_detach exception
+/// </summary>
+_CONCRTIMP nested_scheduler_missing_detach::nested_scheduler_missing_detach() noexcept
+    : exception()
+{
+}
+
+//
+// operation_timed_out -- An operation has timed out.
+//
+
+/// <summary>
+///     Construct an operation_timed_out exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP operation_timed_out::operation_timed_out(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct an operation_timed_out exception
+/// </summary>
+_CONCRTIMP operation_timed_out::operation_timed_out() noexcept
+    : exception()
+{
+}
+
+//
+// invalid_multiple_scheduling -- An exception thrown when a chore/task_handle is scheduled multiple
+// times on one or more *TaskCollection/*task_group constructs before completing.
+//
+
+/// <summary>
+///     Construct an invalid_multiple_scheduling exception with a message
+/// </summary>
+/// <param name="_Message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_multiple_scheduling::invalid_multiple_scheduling(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct an invalid_multiple_scheduling exception
+/// </summary>
+_CONCRTIMP invalid_multiple_scheduling::invalid_multiple_scheduling() noexcept
+    : exception()
+{
+}
+
+//
+//
+// invalid_oversubscribe_operation -- An exception thrown when Context::Oversubscribe(false)
+// is called without calling Context::Oversubscribe(true) first.
+//
+
+/// <summary>
+///     Construct an invalid_oversubscribe_operation exception with a message
+/// </summary>
+/// <param name="_Message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP invalid_oversubscribe_operation::invalid_oversubscribe_operation(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct an invalid_oversubscribe_operation exception
+/// </summary>
+_CONCRTIMP invalid_oversubscribe_operation::invalid_oversubscribe_operation() noexcept
+    : exception()
+{
+}
+
+//
+// improper_lock
+//
+
+/// <summary>
+///     Construct a improper_lock exception with a message
+/// </summary>
+/// <param name="message">
+///     Descriptive message of error
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP improper_lock::improper_lock(const char* message) noexcept
+    : exception(message)
+{ }
+
+/// <summary>
+///     Construct a improper_lock exception
+/// </summary>
+_CONCRTIMP improper_lock::improper_lock() noexcept
+    : exception()
+{
+}
+
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ExecutionResource.cpp

@@ -0,0 +1,222 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ExecutionResource.cpp
+//
+// Part of the ConcRT Resource Manager -- this file contains the internal implementation for the execution
+// resource.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Constructs a new execution resource.
+    /// </summary>
+    /// <param name="pSchedulerProxy">
+    ///     The scheduler proxy this resource is created for. A scheduler proxy holds RM data associated with an instance of
+    ///     a scheduler.
+    /// <param name="pNode">
+    ///     The processor node that this resource belongs to. The processor node is one among the nodes allocated to the
+    ///     scheduler proxy.
+    /// </param>
+    /// <param name="coreIndex">
+    ///     The index into the array of cores for the processor node specified.
+    /// </param>
+    ExecutionResource::ExecutionResource(SchedulerProxy * pSchedulerProxy, SchedulerNode* pNode, unsigned int coreIndex)
+        : m_pSchedulerProxy(pSchedulerProxy)
+        , m_pParentExecutionResource(NULL)
+        , m_pVirtualProcessorRoot(NULL)
+        , m_tlsResetValue(0)
+        , m_nodeId(pNode->m_id)
+        , m_coreIndex(coreIndex)
+        , m_numThreadSubscriptions(0)
+    {
+        // Derive the execution resource id from the node and the core.
+        m_executionResourceId = ((int)(pNode->m_processorGroup) << 8) + pNode->m_pCores[coreIndex].m_processorNumber;
+    }
+
+    /// <summary>
+    ///     Constructs a new execution resource.
+    /// </summary>
+    /// <param name="pSchedulerProxy">
+    ///     The scheduler proxy this resource is created for. A scheduler proxy holds RM data associated with an instance of
+    ///     a scheduler.
+    /// <param name="pParentExecutionResource">
+    ///     The parent execution resource representing this thread. If there was already an execution resource on the
+    ///     calling thread that was created in a different scheduler, it becomes the parent of this execution resource.
+    /// </param>
+    ExecutionResource::ExecutionResource(SchedulerProxy * pSchedulerProxy, ExecutionResource * pParentExecutionResource)
+        : m_pSchedulerProxy(pSchedulerProxy)
+        , m_pParentExecutionResource(pParentExecutionResource)
+        , m_pVirtualProcessorRoot(NULL)
+        , m_tlsResetValue(0)
+        , m_nodeId(pParentExecutionResource->GetNodeId())
+        , m_coreIndex(pParentExecutionResource->GetCoreIndex())
+        , m_numThreadSubscriptions(0)
+    {
+        m_executionResourceId = pParentExecutionResource->GetExecutionResourceId();
+    }
+
+
+    /// <summary>
+    ///     Called to indicate that a scheduler is done with an execution resource and wishes to return it to the resource manager.
+    /// </summary>
+    /// <param name="pScheduler">
+    ///     The scheduler making the request to remove this execution resource.
+    /// </param>
+    void ExecutionResource::Remove(IScheduler *pScheduler)
+    {
+        if (pScheduler == NULL)
+        {
+            throw std::invalid_argument("pScheduler");
+        }
+
+        // Remove must be called on the same thread that called SubscribeCurrentThread.
+        ExecutionResource * pExecutionResource = m_pSchedulerProxy->GetCurrentThreadExecutionResource();
+        if (pExecutionResource != this)
+        {
+            throw invalid_operation();
+        }
+
+        // The scheduler proxy should match the scheduler calling remove.
+        if (m_pSchedulerProxy->Scheduler() != pScheduler)
+        {
+            throw invalid_operation();
+        }
+
+        m_pSchedulerProxy->GetResourceManager()->RemoveExecutionResource(this);
+    }
+
+    /// <summary>
+    ///     Set this execution resource as current on this thread
+    /// </summary>
+    void ExecutionResource::SetAsCurrent()
+    {
+        // Save the information about this execution resource in the TLS for nested SubscribeCurrentThread calls.
+        DWORD tlsSlot = m_pSchedulerProxy->GetResourceManager()->GetExecutionResourceTls();
+        m_tlsResetValue = (size_t) platform::__TlsGetValue(tlsSlot);
+        ASSERT((void *) m_tlsResetValue != (void *)this);
+        platform::__TlsSetValue(tlsSlot, this);
+    }
+
+    /// <summary>
+    ///     Clear the current execution resource on this thread.
+    /// </summary>
+    void ExecutionResource::ResetCurrent()
+    {
+        DWORD tlsSlot = m_pSchedulerProxy->GetResourceManager()->GetExecutionResourceTls();
+        platform::__TlsSetValue(tlsSlot, (void *) m_tlsResetValue);
+        m_tlsResetValue = 0;
+    }
+
+    /// <summary>
+    ///     Increments the number of external threads that run on this execution resource as well as
+    ///     the number of fixed threads that are running on the underlying core.
+    /// </summary>
+    /// <remarks>
+    ///     This information is used to validate matching SubscribeCurrentThread/Release calls, as well as
+    ///     to mark a core on which this resource runs as fixed (not-movable).
+    /// </remarks>
+    void ExecutionResource::IncrementUseCounts()
+    {
+        // The RM LOCK needs to be held before calling this routine
+
+        if (m_numThreadSubscriptions++ == 0)
+        {
+            // For an execution resources associated with a vproc, the threadsubscription count is expected to
+            // go from 0 to 1 when a context running on that vproc subscribes a thread to the scheduler it is running
+            // on or a different scheduler.
+
+            // For an execution resource *not* associated with a vproc, the threadsubscription count is expected to
+            // go from 0 to 1 when it is created.
+            bool isVPRoot = (m_pVirtualProcessorRoot != NULL);
+
+            if (m_pParentExecutionResource == NULL)
+            {
+                // Mark on the core that this execution resource has added a new reference
+                m_pSchedulerProxy->IncrementFixedCoreCount(m_nodeId, m_coreIndex, !isVPRoot);
+
+                if (!isVPRoot)
+                {
+                    // Save old affinity
+                    HANDLE hThread = GetCurrentThread();
+                    m_oldAffinity = HardwareAffinity(hThread);
+
+                    // Affinitize this thread to a given node
+                    HardwareAffinity newAffinity = m_pSchedulerProxy->GetNodeAffinity(m_nodeId);
+                    newAffinity.ApplyTo(hThread);
+
+                    m_pSchedulerProxy->IncrementCoreSubscription(this);
+                    m_pSchedulerProxy->AddExecutionResource(this);
+                }
+            }
+            else
+            {
+                ASSERT(!isVPRoot);
+                m_pSchedulerProxy->AddThreadSubscription(this);
+            }
+
+            SetAsCurrent();
+        }
+    }
+
+    /// <summary>
+    ///     Called to update the proxy counts, which must be done under the RM lock.
+    /// </summary>
+    void ExecutionResource::DecrementUseCounts()
+    {
+        // The RM LOCK needs to be held before calling this routine
+        ASSERT(m_numThreadSubscriptions > 0);
+
+        // This particular call does not have to worry about the RM receiving a SchedulerShutdown for the scheduler proxy in question.
+        if (--m_numThreadSubscriptions == 0)
+        {
+            bool isVPRoot = (m_pVirtualProcessorRoot != NULL);
+            // Reset the TLS to the previous state.
+            // The previous state could be either NULL (if this was not an external threads first subscription),
+            // a pointer to a thread proxy (it if was originally a vproc), or a parent execution resource (if this
+            // was a nested execution resource).
+            ResetCurrent();
+
+            if (m_pParentExecutionResource == NULL)
+            {
+                // Mark on the core that this execution resource has removed one of its references
+                m_pSchedulerProxy->DecrementFixedCoreCount(m_nodeId, m_coreIndex, !isVPRoot);
+
+                if (!isVPRoot)
+                {
+                    m_oldAffinity.ApplyTo(GetCurrentThread());
+                    m_pSchedulerProxy->DecrementCoreSubscription(this);
+                    m_pSchedulerProxy->DestroyExecutionResource(this);
+                }
+            }
+            else
+            {
+                ASSERT(!isVPRoot);
+                m_pParentExecutionResource->DecrementUseCounts();
+                m_pSchedulerProxy->RemoveThreadSubscription(this);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Returns the subscription level on the core that this execution resource represents
+    /// </summary>
+    /// <returns>
+    ///     A current subscription level of the underlying execution resource.
+    /// </returns>
+    unsigned int ExecutionResource::CurrentSubscriptionLevel() const
+    {
+        return m_pSchedulerProxy->GetResourceManager()->CurrentSubscriptionLevel(m_nodeId, m_coreIndex);
+    }
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ExecutionResource.h

@@ -0,0 +1,204 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ExecutionResource.h
+//
+// Part of the ConcRT Resource Manager -- this header file contains the internal definition for the
+// execution resource.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    #pragma warning(push)
+    #pragma warning(disable: 4265) // non-virtual destructor in base class
+    /// <summary>
+    ///     An abstraction for an execution resource -- an entity on top of which a single thread of execution (of whatever
+    ///     type) runs.
+    /// </summary>
+    class ExecutionResource final : public IExecutionResource
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a new execution resource.
+        /// </summary>
+        /// <param name="pSchedulerProxy">
+        ///     The scheduler proxy this resource is created for. A scheduler proxy holds RM data associated with an instance of
+        ///     a scheduler.
+        /// </param>
+        /// <param name="pNode">
+        ///     The processor node that this resource belongs to. The processor node is one among the nodes allocated to the
+        ///     scheduler proxy.
+        /// </param>
+        /// <param name="coreIndex">
+        ///     The index into the array of cores for the processor node specified.
+        /// </param>
+        ExecutionResource(SchedulerProxy *pSchedulerProxy, SchedulerNode* pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Constructs a new execution resource.
+        /// </summary>
+        /// <param name="pSchedulerProxy">
+        ///     The scheduler proxy this resource is created for. A scheduler proxy holds RM data associated with an instance of
+        ///     a scheduler.
+        /// <param name="pParentExecutionResource">
+        ///     The parent execution resource representing this thread
+        ///     scheduler proxy.
+        /// </param>
+        ExecutionResource(SchedulerProxy * pSchedulerProxy, ExecutionResource * pParentExecutionResource);
+
+        /// <summary>
+        ///     Destroys an execution resource.
+        /// </summary>
+        ~ExecutionResource()
+        {
+            ASSERT(m_numThreadSubscriptions == 0);
+        }
+
+        /// <summary>
+        ///     Returns a unique identifier for the node that the given execution resource belongs to.  The identifier returned
+        ///     will fall in the range [0, nodeCount] where nodeCount is the value returned from Concurrency::GetProcessorNodeCount.
+        /// </summary>
+        virtual unsigned int GetNodeId() const
+        {
+            return m_nodeId;
+        }
+
+        /// <summary>
+        ///     Returns a unique identifier for the execution resource that this execution resource runs atop.
+        /// </summary>
+        virtual unsigned int GetExecutionResourceId() const
+        {
+            return m_executionResourceId;
+        }
+
+        /// <summary>
+        ///     Called to indicate that a scheduler is done with an execution resource and wishes to return it to the resource manager.
+        /// </summary>
+        /// <param name="pScheduler">
+        ///     The scheduler making the request to remove this execution resource.
+        /// </param>
+        virtual void Remove(IScheduler *pScheduler);
+
+        /// <summary>
+        ///     Returns the subscription level on the core that this execution resource represents
+        /// </summary>
+        /// <returns>
+        ///     A current subscription level of the underlying execution resource.
+        /// </returns>
+        virtual unsigned int CurrentSubscriptionLevel() const;
+
+        // **************************************************
+        // Internal
+        // **************************************************
+
+        /// <summary>
+        ///     Returns a pointer to the scheduler proxy this execution resource was created by.
+        /// </summary>
+        SchedulerProxy * GetSchedulerProxy()
+        {
+            return m_pSchedulerProxy;
+        }
+
+        /// <summary>
+        ///     Returns the core index into the array of cores, for the node that this execution resource is part of.
+        /// </summary>
+        unsigned int GetCoreIndex()
+        {
+            return m_coreIndex;
+        }
+
+        /// <summary>
+        ///     Retrieves a virtual processor root that contains this execution resource, if any.
+        /// </summary>
+        VirtualProcessorRoot * GetVirtualProcessorRoot()
+        {
+            return m_pVirtualProcessorRoot;
+        }
+
+        /// <summary>
+        ///     Set this execution resource as current on this thread
+        /// </summary>
+        void SetAsCurrent();
+
+        /// <summary>
+        ///     Clear the current execution resource on this thread.
+        /// </summary>
+        void ResetCurrent();
+
+        /// <summary>
+        ///     Initializes the execution resource as either standalone or belonging to virtual processor root.
+        /// </summary>
+        void MarkAsVirtualProcessorRoot(VirtualProcessorRoot * pVPRoot)
+        {
+            ASSERT(m_pVirtualProcessorRoot == NULL);
+            m_pVirtualProcessorRoot = pVPRoot;
+        }
+
+        /// <summary>
+        ///     Increments the number of external threads that run on this execution resource as well as
+        ///     the number of fixed threads that are running on the underlying core.
+        /// </summary>
+        /// <remarks>
+        ///     This information is used to validate matching SubscribeCurrentThread/Release calls, as well as
+        ///     to mark a core on which this resource runs as fixed (not-movable).
+        /// </remarks>
+        void IncrementUseCounts();
+
+        /// <summary>
+        ///     Called to update the crucial counts, which must be done under the RM lock.
+        /// </summary>
+        void DecrementUseCounts();
+
+    protected:
+
+        // Guards critical regions of the Execution Resource
+        _NonReentrantLock m_lock;
+
+        // The previous affinity of the external thread
+        HardwareAffinity m_oldAffinity;
+
+        // The scheduler proxy associated with the scheduler for which
+        // this resource was created.
+        SchedulerProxy * m_pSchedulerProxy;
+
+        // Parent execution resource in the case of a nested subscribe
+        ExecutionResource * m_pParentExecutionResource;
+
+        // Virtual processor root that this execution resource is a part of, if any
+        VirtualProcessorRoot * m_pVirtualProcessorRoot;
+
+        // The value to use when external resource subscription of a virtual processor is removed
+        size_t m_tlsResetValue;
+
+        // The node to which this execution resource belongs.
+        unsigned int m_nodeId;
+
+        // The core index within this node.
+        unsigned int m_coreIndex;
+
+        // The hardware thread upon which this execution resource executes.
+        unsigned int m_executionResourceId;
+
+        // Number of subscription requests that have been received for this execution resource.
+        unsigned int m_numThreadSubscriptions;
+
+    private:
+        template <class T, class Counter> friend class List;
+
+        // Intrusive links
+        ExecutionResource * m_pPrev{}, * m_pNext{};
+    };
+
+    #pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ExternalContextBase.cpp

@@ -0,0 +1,325 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ExternalContextBase.cpp
+//
+// Source file containing the metaphor for an external execution ContextBase/stack/thread.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#include "concrtinternal.h"
+
+#pragma warning (disable : 4702)
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Constructs an external context.
+    /// </summary>
+    /// <param name="pScheduler">
+    ///     The scheduler the context will belong to.
+    /// </param>
+    /// <param name="explicitAttach">
+    ///     Whether or not this is an explicit attach. An explicit attach occurs as a result of calling a scheduler
+    ///     creation API, or the scheduler attach API. The scheduler will not detach implicitly for explicitly
+    ///     attached threads, on thread exit.
+    /// </param>
+    ExternalContextBase::ExternalContextBase(SchedulerBase *pScheduler, bool explicitAttach) :
+        ContextBase(pScheduler, true),
+        m_pSubAllocator(NULL),
+        m_hPhysicalContext(NULL)
+    {
+        // Create an auto-reset event that is initially not signaled.
+        m_hBlock = platform::__CreateAutoResetEvent(); // VSO#459907
+
+        // External contexts are all grouped together in the 'anonymous' schedule group.
+        m_pSegment = m_pScheduler->GetAnonymousScheduleGroupSegment();
+
+        // Create external context statistics as a place where this external context we are about to create
+        // will store all the statistical data.
+        m_pStats = _concrt_new ExternalStatistics(); // VSO#459907
+        m_pScheduler->AddExternalStatistics(m_pStats);
+
+        // Initialize data that is reset each time the external context is reused.
+        PrepareForUse(explicitAttach);
+    }
+
+#if !defined(_ONECORE)
+    /// <summary>
+    ///     Callback to indicate the exit of one of the external threads. This function
+    ///     is invoked on the wait thread. It is assumed that this function is short and quick.
+    /// </summary>
+    void CALLBACK ExternalContextBase::ImplicitDetachHandler(PTP_CALLBACK_INSTANCE instance, PVOID parameter, PTP_WAIT waiter, TP_WAIT_RESULT waitResult)
+    {
+        ExternalContextBase * pContext = reinterpret_cast<ExternalContextBase *>(parameter);
+
+        ASSERT(waitResult == WAIT_OBJECT_0);
+
+        pContext->m_pScheduler->DetachExternalContext(pContext, false);
+
+        // This is non-blocking
+        UnRegisterAsyncWaitAndUnloadLibrary(instance, waiter);
+    }
+#endif // !defined(_ONECORE)
+
+    /// <summary>
+    ///     Same callback function as ImplicitDetachHandler but used on XP.
+    /// </summary>
+    void CALLBACK ExternalContextBase::ImplicitDetachHandlerXP(PVOID parameter, BOOLEAN is_timeout)
+    {
+        ExternalContextBase * pContext = reinterpret_cast<ExternalContextBase *>(parameter);
+
+        // This is non-blocking
+        platform::__UnregisterWait(pContext->m_hWaitHandle);
+
+        ASSERT(!is_timeout);
+
+        pContext->m_pScheduler->DetachExternalContext(pContext, false);
+    }
+
+    /// <summary>
+    ///     Initializes fields that need re-initialization when an external context is recycled. This is called
+    ///     in the constructor and when an external context is taken off the idle pool for reuse.
+    /// </summary>
+    /// <param name="explicitAttach">
+    ///     Whether or not this is an explicit attach. An explicit attach occurs as a result of calling a scheduler
+    ///     creation API, or the scheduler attach API. The scheduler will not detach implicitly for explicitly
+    ///     attached threads, on thread exit.
+    /// </param>
+    void ExternalContextBase::PrepareForUse(bool explicitAttach)
+    {
+        // Even in the case of a nested external context being initialized, we expect the TLS slot to be clear.
+        ASSERT(SchedulerBase::FastCurrentContext() == NULL);
+
+        m_fExplicitlyAttached = explicitAttach;
+        m_threadId = GetCurrentThreadId();
+
+        if (!explicitAttach)
+        {
+            // We only need to capture the current thread's handle for an implicit attach, so that we can register the
+            // handle for exit tracking, in order that references may be released on thread exit.
+            if (!DuplicateHandle(GetCurrentProcess(),
+                             GetCurrentThread(),
+                             GetCurrentProcess(),
+                             &m_hPhysicalContext,
+                             0,
+                             FALSE,
+                             DUPLICATE_SAME_ACCESS))
+            {
+                throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+            }
+
+#if !defined(_ONECORE)
+            // Request a thread pool thread to wait for this thread exit.
+            if ((m_hWaitHandle = RegisterAsyncWaitAndLoadLibrary(m_hPhysicalContext, ExternalContextBase::ImplicitDetachHandler, this)) == nullptr)
+            {
+                throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+            }
+#else // ^^^ !defined(_ONECORE) / defined(_ONECORE) vvv
+            m_hWaitHandle = platform::__RegisterWaitForSingleObject(m_hPhysicalContext, ExternalContextBase::ImplicitDetachHandlerXP, this);
+#endif // ^^^ defined(_ONECORE) ^^^
+        }
+    }
+
+    /// <summary>
+    ///     Causes the external context to block. Since external contexts do not execute on virtual processors,
+    ///     the context does not switch to another one. Instead, it stops executing until it is unblocked.
+    /// </summary>
+    void ExternalContextBase::Block()
+    {
+        ASSERT(this == SchedulerBase::FastCurrentContext());
+
+        TraceContextEvent(CONCRT_EVENT_BLOCK, TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);
+
+        if (InterlockedIncrement(&m_contextSwitchingFence) == 1)
+        {
+            WaitForSingleObjectEx(m_hBlock, INFINITE, FALSE);
+        }
+        else
+        {
+            // Skip the block, since an unblock has already been encountered.
+        }
+    }
+
+    /// <summary>
+    ///     Unblocks the external context causing it to start running.
+    /// </summary>
+    void ExternalContextBase::Unblock()
+    {
+        if (this != SchedulerBase::FastCurrentContext())
+        {
+            TraceContextEvent(CONCRT_EVENT_UNBLOCK, TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);
+
+            LONG newValue = InterlockedDecrement(&m_contextSwitchingFence);
+
+            if (newValue == 0)
+            {
+                SetEvent(m_hBlock);
+            }
+            else
+            {
+                if ((newValue < -1) || (newValue > 0))
+                {
+                    // Should not be able to get m_contextSwitchingFence above 0.
+                    ASSERT(newValue < -1);
+
+                    throw context_unblock_unbalanced();
+                }
+            }
+        }
+        else
+        {
+            throw context_self_unblock();
+        }
+    }
+
+    /// <summary>
+    ///     Just a thread yield on the current processor.
+    /// </summary>
+    void ExternalContextBase::Yield()
+    {
+        TraceContextEvent(CONCRT_EVENT_YIELD, TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);
+
+        platform::__SwitchToThread();
+    }
+
+    /// <summary>
+    ///     See comments for Concurrency::Context::Oversubscribe.
+    ///     External contexts do not support oversubscription. However, we keep track of calls and throw exceptions
+    ///     when appropriate.
+    /// </summary>
+    void ExternalContextBase::Oversubscribe(bool beginOversubscription)
+    {
+        if (beginOversubscription)
+        {
+            ++m_oversubscribeCount;
+        }
+        else
+        {
+            if (m_oversubscribeCount == 0)
+            {
+                throw invalid_oversubscribe_operation();
+            }
+            --m_oversubscribeCount;
+        }
+    }
+
+    /// <summary>
+    ///     Allocates a block of memory of the size specified.
+    /// </summary>
+    /// <param name="numBytes">
+    ///     Number of bytes to allocate.
+    /// </param>
+    /// <returns>
+    ///     A pointer to newly allocated memory.
+    /// </returns>
+    void* ExternalContextBase::Alloc(size_t numBytes)
+    {
+        void* pAllocation = NULL;
+        ASSERT(SchedulerBase::FastCurrentContext() == this);
+
+        // Find the suballocator for this external context if there is one. Note that if we are unable to get an allocator now,
+        // we may be able to get one for a later Alloc or Free call (if a different external context released its allocator to
+        // the free pool).
+        SubAllocator* pAllocator = GetCurrentSubAllocator();
+
+        if (pAllocator != NULL)
+        {
+            pAllocation = pAllocator->Alloc(numBytes);
+        }
+        else
+        {
+            // Allocate from the CRT heap. At the point this allocation is freed, if the context has a suballocator, it will be
+            // freed to the suballocator of the context.
+            pAllocation = SubAllocator::StaticAlloc(numBytes);
+        }
+
+        return pAllocation;
+    }
+
+    /// <summary>
+    ///     Frees a block of memory previously allocated by the Alloc API.
+    /// </summary>
+    /// <param name="pAllocation">
+    ///     A pointer to an allocation previously allocated by Alloc.
+    /// </param>
+    void ExternalContextBase::Free(void* pAllocation)
+    {
+        ASSERT(SchedulerBase::FastCurrentContext() == this);
+        ASSERT(pAllocation != NULL);
+
+        // Find the suballocator for this external context if there is one. Note that if we are unable to get an allocator now,
+        // we may be able to get one for a later Alloc or Free call (if a different external context released its allocator to
+        // the free pool).
+        SubAllocator* pAllocator = GetCurrentSubAllocator();
+
+        if (pAllocator != NULL)
+        {
+            pAllocator->Free(pAllocation);
+        }
+        else
+        {
+            // Free to the CRT heap.
+            SubAllocator::StaticFree(pAllocation);
+        }
+    }
+
+    /// <summary>
+    ///     Prepares an external context for the idle pool by releasing some resources.
+    /// </summary>
+    void ExternalContextBase::RemoveFromUse()
+    {
+        ReleaseWorkQueue();
+
+        CONCRT_COREASSERT(GetCriticalRegionType() == OutsideCriticalRegion);
+
+        if (m_hPhysicalContext != NULL)
+        {
+            CloseHandle(m_hPhysicalContext);
+            m_hPhysicalContext = NULL;
+        }
+    }
+
+    /// <summary>
+    ///     Destroys an external thread based context.
+    /// </summary>
+    ExternalContextBase::~ExternalContextBase()
+    {
+        // This takes care of calling the cleanup routine for ContextBase.
+        Cleanup();
+    }
+
+    /// <summary>
+    ///     Performs cleanup of the external context
+    /// </summary>
+    void ExternalContextBase::Cleanup()
+    {
+        ContextBase::Cleanup();
+        //
+        // m_pGroup is an anonymous schedule group that is destroyed at scheduler shutdown, so don't release here.
+        //
+        if (m_hPhysicalContext != NULL)
+        {
+            CloseHandle(m_hPhysicalContext);
+            m_hPhysicalContext = NULL;
+        }
+        if (m_hBlock)
+        {
+            CloseHandle(m_hBlock);
+        }
+        if (m_pSubAllocator != NULL)
+        {
+            SchedulerBase::ReturnSubAllocator(m_pSubAllocator);
+        }
+
+        // Mark the scheduler's list of non-internal contexts (external or non-bound to context) for removal. We
+        // can't remove this item yet because statistics might not have had a chance to aggregate this information yet.
+        DetachStatistics();
+    }
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ExternalContextBase.h

@@ -0,0 +1,384 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ExternalContextBase.h
+//
+// Header file containing the metaphor for an external execution context.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Provides a storage area for external contexts bound to this scheduler or alien threads (threads not
+    ///     associated with any scheduler or those associated with scheduler other than this one) where they can put
+    ///     the statistical data necessary to track the rate of work.
+    /// </summary>
+
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class ExternalStatistics
+    {
+    public:
+        //
+        // Public methods
+        //
+
+        /// <summary>
+        ///     Constructs the statistics object for an external context or alien thread.
+        /// </summary>
+        ExternalStatistics() : m_enqueuedTaskCounter(0), m_dequeuedTaskCounter(0), m_enqueuedTaskCheckpoint(0), m_dequeuedTaskCheckpoint(0), m_fIsActive(true)
+        {
+        }
+
+        /// <summary>
+        ///     Increments the count of work coming in.
+        /// </summary>
+        void IncrementEnqueuedTaskCounter()
+        {
+            m_enqueuedTaskCounter++;
+        }
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter()
+        {
+            m_dequeuedTaskCounter++;
+        }
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter(unsigned int count)
+        {
+            m_dequeuedTaskCounter += count;
+        }
+
+        /// <summary>
+        ///     Resets the count of work coming in.
+        /// </summary>
+        /// <remarks>
+        ///     This function will reset the state so that the next time it is called, it reports only the
+        ///     units of work that came in since the last time. One obvious solution is to reset the
+        ///     counter, but that introduces a race with a thread that tries to increment. Instead,
+        ///     we update the trailing counter to match the current count. This way the difference
+        ///     between the two is always the number of work coming in. By keeping these numbers unsigned
+        ///     we make use of "modulo 2" behavior of unsigned ints and avoid overflow problems.
+        ///
+        ///     NOTE: There is a highly rare condition present in this code. If, for some reason,
+        //      statistics calls were infrequent enough that UINT_MAX units of work were enqueued
+        ///     between two calls we will wrap around and consequently think that no work came in at all.
+        /// </remarks>
+        /// <returns>
+        ///     Previous value of the counter.
+        /// </returns>
+        unsigned int GetEnqueuedTaskCount()
+        {
+            unsigned int currentValue = m_enqueuedTaskCounter;
+            unsigned int retVal = currentValue - m_enqueuedTaskCheckpoint;
+
+            // Update the checkpoint value with the current value
+            m_enqueuedTaskCheckpoint = currentValue;
+
+            ASSERT(retVal < INT_MAX);
+            return retVal;
+        }
+
+        /// <summary>
+        ///     Resets the count of work being done.
+        /// </summary>
+        /// <remarks>
+        ///     Look at remarks for GetEnqueuedTaskCount.
+        /// </remarks>
+        /// <returns>
+        ///     Previous value of the counter.
+        /// </returns>
+        unsigned int GetDequeuedTaskCount()
+        {
+            unsigned int currentValue = m_dequeuedTaskCounter;
+            unsigned int retVal = currentValue - m_dequeuedTaskCheckpoint;
+
+            // Update the checkpoint value with the current value
+            m_dequeuedTaskCheckpoint = currentValue;
+
+            ASSERT(retVal < INT_MAX);
+            return retVal;
+        }
+
+        /// <summary>
+        ///     Marks this statistics as not active anymore. This means that external context
+        ///     has gone away and it will no longer update the statistical information. However,
+        ///     we can't remove statistics right away because they might not have been collected yet.
+        ///     So, we mark it as inactive and we wait for the next collection to take place before
+        ///     permanently retiring this statistics.
+        /// </summary>
+        void MarkInactive()
+        {
+            m_fIsActive = FALSE;
+        }
+
+        /// <summary>
+        ///     Checks whether this statistics class expects any new updates.
+        /// </summary>
+        /// <returns>
+        ///     True if statistics is still active.
+        /// </returns>
+        bool IsActive()
+        {
+            // By the memory ordering rules the only way that m_fIsActive would be marked as false
+            // is if external context is being destroyed, which means there is no work coming in or
+            // out of this external context. The task counts are final and there is no race between
+            // task counts and active bit.
+            return (m_fIsActive || (m_enqueuedTaskCounter != m_enqueuedTaskCheckpoint) || (m_dequeuedTaskCounter != m_dequeuedTaskCheckpoint));
+        }
+
+        // A field that is necessary to store the statistics data structure in a ListArray<ExternalStatistics>
+        int m_listArrayIndex{};
+
+    private:
+        //
+        // Private data
+        //
+
+        template <class T> friend class ListArray;
+
+        // Intrusive links for list array.
+        SLIST_ENTRY m_listArrayFreeLink{};
+
+        // Statistics data counters
+        unsigned int m_enqueuedTaskCounter;
+        unsigned int m_dequeuedTaskCounter;
+
+        // Statistics data checkpoints
+        unsigned int m_enqueuedTaskCheckpoint;
+        unsigned int m_dequeuedTaskCheckpoint;
+
+        // Whether this statistics is actively worked on
+        volatile BOOL m_fIsActive;
+    };
+#pragma warning(pop)
+
+    /// <summary>
+    /// Implements the base class for ConcRT external contexts.
+    /// </summary>
+    class ExternalContextBase : public ContextBase
+    {
+    public:
+
+        //
+        // Public methods
+        //
+
+        /// <summary>
+        ///     Constructs an external context.
+        /// </summary>
+        ExternalContextBase(SchedulerBase *pScheduler, bool explicitAttach);
+
+        /// <summary>
+        ///     Destroys an external context.
+        /// </summary>
+        virtual ~ExternalContextBase();
+
+        /// <summary>
+        ///     Causes the external context to block. Since external contexts do not execute on virtual processors,
+        ///     the context does not switch to another one. Instead, it stops executing until it is unblocked.
+        /// </summary>
+        virtual void Block();
+
+        /// <summary>
+        ///     Unblocks the external context causing it to start running.
+        /// </summary>
+        virtual void Unblock();
+
+        /// <summary>
+        ///     Since there is no underlying virtual processor, the yield operation is a no-op for external contexts.
+        /// </summary>
+        virtual void Yield();
+
+        /// <summary>
+        ///     Since there is no underlying virtual processor, the yield operation is a no-op for external contexts.
+        /// </summary>
+        virtual void SpinYield()
+        {
+            Yield();
+        }
+
+        /// <summary>
+        ///     See comments for Concurrency::Context::Oversubscribe.
+        /// </summary>
+        virtual void Oversubscribe(bool beginOversubscription);
+
+        /// <summary>
+        ///     Allocates a block of memory of the size specified.
+        /// </summary>
+        /// <param name="numBytes">
+        ///     Number of bytes to allocate.
+        /// </param>
+        /// <returns>
+        ///     A pointer to newly allocated memory.
+        /// </returns>
+        virtual void* Alloc(size_t numBytes);
+
+        /// <summary>
+        ///     Frees a block of memory previously allocated by the Alloc API.
+        /// </summary>
+        /// <param name="pAllocation">
+        ///     A pointer to an allocation previously allocated by Alloc.
+        /// </param>
+        virtual void Free(void* pAllocation);
+
+        /// <summary>
+        ///     Tells whether the context was explicitly attached to the scheduler at the time it was created
+        /// </summary>
+        bool WasExplicitlyAttached() const { return m_fExplicitlyAttached; }
+
+        /// <summary>
+        ///     Returns an identifier to the virtual processor the context is currently executing on, if any.
+        /// </summary>
+        virtual unsigned int GetVirtualProcessorId() const { return UINT_MAX; }
+
+        /// <summary>
+        ///     Initializes fields that need re-initialization when an external context is reused. This is called
+        ///     in the constructor and when an external context is taken off the idle pool for reuse.
+        /// </summary>
+        void PrepareForUse(bool explicitAttach);
+
+        /// <summary>
+        ///     Prepares an external context for the idle pool by releasing some resources.
+        /// </summary>
+        void RemoveFromUse();
+
+        /// <summary>
+        ///     Returns a handle to the underlying thread.
+        /// </summary>
+        HANDLE GetPhysicalContext() { return m_hPhysicalContext; }
+
+        /// <summary>
+        ///     Returns a pointer to the suballocator for this external context. Note that the RM call to get an
+        ///     allocator can return NULL, since the RM only hands out a fixed number of allocators for external
+        ///     contexts.
+        /// </summary>
+        SubAllocator* GetCurrentSubAllocator()
+        {
+            if (m_pSubAllocator == NULL)
+            {
+                m_pSubAllocator = SchedulerBase::GetSubAllocator(true);
+            }
+            return m_pSubAllocator;
+        }
+
+        /// <summary>
+        ///     Increments the count of work coming in.
+        /// </summary>
+        void IncrementEnqueuedTaskCounter()
+        {
+            m_pStats->IncrementEnqueuedTaskCounter();
+        }
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter()
+        {
+            m_pStats->IncrementDequeuedTaskCounter();
+        }
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter(unsigned int count)
+        {
+            m_pStats->IncrementDequeuedTaskCounter(count);
+        }
+
+        /// <summary>
+        ///     Orphan the statistics and let it know there will be no more updates.
+        /// </summary>
+        /// <returns>
+        ///     The statistics that were attached to this external context.
+        /// </returns>
+        ExternalStatistics * DetachStatistics()
+        {
+            ExternalStatistics * externalStatistics = m_pStats;
+            m_pStats = NULL;
+            externalStatistics->MarkInactive();
+
+            return externalStatistics;
+        }
+
+        /// <summary>
+        ///     Determines whether or not the context is synchronously blocked at this given time.
+        /// </summary>
+        /// <returns>
+        ///     Whether context is in synchronous block state.
+        /// </returns>
+        virtual bool IsSynchronouslyBlocked() const
+        {
+            return (m_contextSwitchingFence == 1);
+        }
+
+#if _DEBUG
+        // _DEBUG helper
+        DWORD GetThreadId() const { return m_threadId; }
+#endif
+
+    private:
+        friend class SchedulerBase;
+        template<class T> friend void _InternalDeleteHelper(T*);
+
+        //
+        // Private data
+        //
+
+        // Specifies whether the context was created as a result of an explicit or implicit attach.
+        bool m_fExplicitlyAttached;
+
+        // Statistical information for this external context.
+        ExternalStatistics * m_pStats;
+
+        // A pointer to the suballocator for this context.
+        SubAllocator * m_pSubAllocator;
+
+        // Handle to the underlying thread.
+        HANDLE m_hPhysicalContext;
+
+        // Handle to the event used for blocking.
+        HANDLE m_hBlock;
+
+        // Wait handle for thread exit event (used on XP)
+        HANDLE m_hWaitHandle;
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Performs cleanup of the external context
+        /// </summary>
+        void Cleanup();
+
+        /// <summary>
+        ///     Callback to indicate the exit of one of the external threads.
+        /// </summary>
+        static void CALLBACK ImplicitDetachHandler(PTP_CALLBACK_INSTANCE instance, PVOID parameter, PTP_WAIT waiter, TP_WAIT_RESULT waitResult);
+
+        /// <summary>
+        ///     Same callback function as ImplicitDetachHandler but used on XP.
+        /// </summary>
+        static void CALLBACK ImplicitDetachHandlerXP(PVOID parameter, BOOLEAN is_timeout);
+
+        /// <summary>
+        ///     Returns the type of context
+        /// </summary>
+        virtual ContextKind GetContextKind() const { return ExternalContext; }
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FairScheduleGroup.cpp

@@ -0,0 +1,107 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FairScheduleGroup.cpp
+//
+// Implementation file for FairScheduleGroup.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Puts a runnable context into the runnables collection in the schedule group.
+    /// </summary>
+    void FairScheduleGroupSegment::AddToRunnablesCollection(InternalContextBase* pContext)
+    {
+        m_runnableContexts.Enqueue(pContext);
+    }
+
+    /// <summary>
+    ///     Locates a segment that is appropriate for scheduling a task within the schedule group given information about the task's placement
+    ///     and the origin of the thread making the call.
+    /// </summary>
+    /// <param name="pSegmentAffinity">
+    ///     A segment with affinity to this particular location will be located.
+    /// </param>
+    /// <param name="fCreateNew">
+    ///     An indication as to whether the schedule group can create a new segment if an appropriate segment cannot be found.  If this parameter is
+    ///     specified as true, NULL will never be returned from this method; otherwise, it can be if no matching segment can be found.
+    /// </param>
+    /// <returns>
+    ///     A segment appropriate for scheduling work with affinity to segmentAffinity from code executing at origin.  Note that NULL may be returned
+    ///     if fCreateNew is specified as false and no appropriate segment yet exists for the group.
+    /// </returns>
+    ScheduleGroupSegmentBase *FairScheduleGroup::LocateSegment(location*, bool fCreateNew)
+    {
+        // Ignore the passed in affinity for fair schedule groups.
+        location unbiased;
+        if (m_kind & AnonymousScheduleGroup)
+        {
+            //
+            // In order to provide a "like" functionality to Dev10 for anonymous fair groups, we still let the group be split by rings.  Non-anonymous
+            // groups are also treated identically to Dev10 -- they live in one ring which is more for separation than any biasing.
+            //
+            return ScheduleGroupBase::LocateSegment(&unbiased, fCreateNew);
+        }
+        else
+        {
+            ScheduleGroupSegmentBase *pSegment = m_pDefaultSegment;
+            if (fCreateNew && !pSegment)
+            {
+                m_segmentLock._Acquire();
+                if (m_pDefaultSegment)
+                {
+                    pSegment = m_pDefaultSegment;
+                }
+                else
+                {
+                    pSegment = CreateSegment(&unbiased, m_pScheduler->GetNextSchedulingRing());
+                    // CreateSegment adds the segment to the list array as its last step, which generates a fence ensuring that the segment
+                    // is fully initialized before it is published on weaker memory models.
+                    m_pDefaultSegment = static_cast<FairScheduleGroupSegment *>(pSegment);
+                }
+                m_segmentLock._Release();
+            }
+
+            return pSegment;
+        }
+    }
+
+    /// <summary>
+    ///     Internal routine which finds an appropriate segment for a task placement.
+    /// </summary>
+    /// <param name="pSegmentAffinity">
+    ///     A segment with this affinity will be located.
+    /// </param>
+    /// <param name="pRing">
+    ///     A segment with segmentAffinity within this ring will be found.  A given location may be split into multiple segments by node in order
+    ///     to keep work local.
+    /// </param>
+    /// <returns>
+    ///     A segment with the specified affinity close to the specified location.
+    /// </returns>
+    ScheduleGroupSegmentBase *FairScheduleGroup::FindSegment(location*, SchedulingRing *pRing)
+    {
+        // Ignore the passed in affinity for fair schedule groups
+        location unbiased;
+        if (m_kind & AnonymousScheduleGroup)
+        {
+            return ScheduleGroupBase::FindSegment(&unbiased, pRing);
+        }
+        else
+        {
+            return m_pDefaultSegment;
+        }
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FairScheduleGroup.h

@@ -0,0 +1,199 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FairScheduleGroup.h
+//
+// Header file containing FairScheduleGroup related declarations.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    class FairScheduleGroup;
+
+    class FairScheduleGroupSegment : public ScheduleGroupSegmentBase
+    {
+
+    public:
+
+        //
+        // Public Methods
+        //
+
+        /// <summary>
+        ///     Constructs a fair schedule group segment
+        /// </summary>
+        FairScheduleGroupSegment(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location* pSegmentAffinity) :
+            ScheduleGroupSegmentBase(pOwningGroup, pOwningRing, pSegmentAffinity)
+        {
+        }
+
+        /// <summary>
+        ///     Notifies virtual processors that work affinitized to them has become available in the schedule group segment.
+        /// </summary>
+        virtual void NotifyAffinitizedWork() { }
+
+    private:
+        friend class SchedulerBase;
+        friend class FairScheduleGroup;
+        friend class ContextBase;
+        friend class ExternalContextBase;
+        friend class InternalContextBase;
+        friend class ThreadInternalContext;
+        friend class SchedulingNode;
+        friend class SchedulingRing;
+        friend class VirtualProcessor;
+
+        //
+        // Private data
+        //
+
+        // Each schedule group has three stores of work. It has a collection of runnable contexts,
+        // a FIFO queue of realized chores and a list of workqueues that hold unrealized chores.
+
+        // A collection of Runnable contexts.
+        SafeSQueue<InternalContextBase, _HyperNonReentrantLock> m_runnableContexts;
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Puts a runnable context into the runnables collection in the schedule group.
+        /// </summary>
+        void AddToRunnablesCollection(InternalContextBase *pContext);
+
+        InternalContextBase *GetRunnableContext()
+        {
+            if (m_runnableContexts.Empty())
+                return NULL;
+
+            InternalContextBase *pContext = m_runnableContexts.Dequeue();
+#if defined(_DEBUG)
+            SetContextDebugBits(pContext, CTX_DEBUGBIT_REMOVEDFROMRUNNABLES);
+#endif // _DEBUG
+            return pContext;
+        }
+
+    };
+
+    class FairScheduleGroup : public ScheduleGroupBase
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a new fair schedule group.
+        /// </summary>
+        FairScheduleGroup(SchedulerBase *pScheduler, location* pGroupPlacement) :
+            ScheduleGroupBase(pScheduler, pGroupPlacement),
+            m_pDefaultSegment(NULL)
+        {
+            ASSERT(pGroupPlacement->_Is_system());
+            m_kind = FairScheduling;
+        }
+
+        /// <summary>
+        ///     Locates a segment that is appropriate for scheduling a task within the schedule group given information about the task's placement
+        ///     and the origin of the thread making the call.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     A segment with affinity to this particular location will be located.
+        /// </param>
+        /// <param name="fCreateNew">
+        ///     An indication as to whether the schedule group can create a new segment if an appropriate segment cannot be found.  If this parameter is
+        ///     specified as true, NULL will never be returned from this method; otherwise, it can be if no matching segment can be found.
+        /// </param>
+        /// <returns>
+        ///     A segment appropriate for scheduling work with affinity to segmentAffinity from code executing at origin.  Note that NULL may be returned
+        ///     if fCreateNew is specified as false and no appropriate segment yet exists for the group.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase *LocateSegment(location* pSegmentAffinity, bool fCreateNew);
+
+        /// <summary>
+        ///     Places a chore in a mailbox associated with the schedule group which is biased towards tasks being picked up from the specified
+        ///     location. For a fair schedule group, the function returns an empty slot
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to mail.
+        /// </param>
+        /// <param name="pPlacement">
+        ///     A pointer to a location where the chore will be mailed.
+        /// </param>
+        /// <returns>
+        ///     The mailbox slot into which the chore was placed.
+        /// </returns>
+        /// <remarks>
+        ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+        ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+        /// </remarks>
+        virtual Mailbox<_UnrealizedChore>::Slot MailChore(_UnrealizedChore * pChore,
+                                                          location * pPlacement,
+                                                          ScheduleGroupSegmentBase **)
+        {
+            (pChore); (pPlacement);
+            return Mailbox<_UnrealizedChore>::Slot();
+        }
+    protected:
+
+        /// <summary>
+        ///     Allocates a new fair schedule group segment within the specified group and ring with the specified affinity.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity for the segment.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The scheduling ring to which the newly allocated segment will belong.
+        /// </param>
+        /// <returns>
+        ///     A new fair schedule group within the specified group and ring with the specified affinity.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase* AllocateSegment(SchedulingRing *pOwningRing, location* pSegmentAffinity)
+        {
+            //
+            // For fair schedule groups, we completely ignore any location hint since we are directed to round robin the groups anyway!
+            //
+            (pSegmentAffinity);
+            location unbiased;
+            return _concrt_new FairScheduleGroupSegment(this, pOwningRing, &unbiased);
+        }
+
+        /// <summary>
+        ///     Internal routine which finds an appropriate segment for a task placement.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     A segment with this affinity will be located.
+        /// </param>
+        /// <param name="pRing">
+        ///     A segment with segmentAffinity within this ring will be found.  A given location may be split into multiple segments by node in order
+        ///     to keep work local.
+        /// </param>
+        /// <returns>
+        ///     A segment with the specified affinity close to the specified location.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase *FindSegment(location* pSegmentAffinity, SchedulingRing *pRing);
+
+        /// <summary>
+        ///     Removes all schedule group segments from the group.
+        /// </summary>
+        virtual void RemoveSegments()
+        {
+            ScheduleGroupBase::RemoveSegments();
+            m_pDefaultSegment = NULL;
+        }
+
+    private:
+
+        FairScheduleGroupSegment *m_pDefaultSegment;
+
+    };
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FreeThreadProxy.cpp

@@ -0,0 +1,216 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FreeThreadProxy.cpp
+//
+// Part of the ConcRT Resource Manager -- this source file contains the internal definition for the free thread
+// proxy.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Called in order to perform a cooperative context switch between one context and another.  After this call, pContext will
+    ///     be running atop the virtual processor root and the context which was running will not.  What happens to the context that
+    ///     was running depends on the value of the reason argument.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context to cooperatively switch to.
+    /// </param>
+    /// <param name="switchState">
+    ///     Indicates the state of the thread proxy that is executing the switch.  This can determine ownership of the underlying thread
+    ///     proxy and context.
+    /// </param>
+    void FreeThreadProxy::SwitchTo(Concurrency::IExecutionContext *pContext, SwitchingProxyState switchState)
+    {
+        if (pContext == NULL)
+            throw std::invalid_argument("pContext");
+
+        // Find out if this context already has a thread proxy, if not, we have to request one from the factory.
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *> (pContext->GetProxy());
+
+        if (pProxy == NULL)
+        {
+            // Find a thread proxy from the pool that corresponds to the stack size and priority we need. Since this
+            // is a context in the same scheduler as the current context's scheduler, we can use existing values of
+            // stack size and priority.
+            pProxy = static_cast<FreeThreadProxy *> (m_pRoot->GetSchedulerProxy()->GetNewThreadProxy(pContext));
+        }
+
+        FreeVirtualProcessorRoot *pRoot = static_cast<FreeVirtualProcessorRoot *>(m_pRoot);
+        m_pRoot = NULL;
+
+        if (switchState == Blocking)
+        {
+            ASSERT(m_fBlocked == FALSE);
+            InterlockedExchange(&m_fBlocked, TRUE);
+        }
+
+        // The 'next' thread proxy must be affinitized to a copy of the 'this' proxy's vproc root VPRoot1, snapped BEFORE the blocked flag
+        // is set. Not doing this could result in vproc root orphanage. See VirtualProcessorRoot::Affinitize for details.
+        pRoot->Affinitize(pProxy);
+
+        switch (switchState)
+        {
+            case Blocking:
+                //
+                // Signal the other thread proxy and block until switched to, or until a virtual processor is activated with
+                // the context running on this thread proxy.
+                //
+                platform::__SignalObjectAndWait(pProxy->m_hBlock, m_hBlock, INFINITE, TRUE);
+                ASSERT(m_fBlocked == TRUE);
+                InterlockedExchange(&m_fBlocked, FALSE);
+
+                break;
+            case Nesting:
+                //
+                // Signal the other thread proxy that now owns this virtual processor, but do not block. The current thread proxy
+                // is about to move to a nested scheduler.
+                //
+                ASSERT(pProxy->m_pRoot != NULL);
+                ASSERT(pProxy->m_pContext != NULL);
+                pProxy->ResumeExecution();
+
+                break;
+            case Idle:
+                //
+                // Return without blocking, indicating to the caller that the scheduler should yield this thread proxy
+                // back to the RM, by exiting the contexts dispatch loop.
+                //
+                ASSERT(pProxy->m_pRoot != NULL);
+                ASSERT(pProxy->m_pContext != NULL);
+                pProxy->ResumeExecution();
+
+                break;
+            default:
+
+                ASSERT(false);
+                break;
+        }
+    }
+
+    /// <summary>
+    ///     Called in order to disassociate the currently executing context from its virtual processor root, and reinitialize the root
+    ///     for future use.
+    /// </summary>
+    /// <param name="switchState">
+    ///     Indicates the state of the thread proxy that is executing the switch.  This can determine ownership of the underlying thread
+    ///     proxy and context.
+    /// </param>
+    void FreeThreadProxy::SwitchOut(SwitchingProxyState switchState)
+    {
+        if ((switchState == Idle) || (m_pRoot == NULL && switchState != Blocking))
+            throw std::invalid_argument("switchState");
+
+        ASSERT(m_fBlocked == 0);
+
+        //
+        // If a virtual processor root is removed on the thread running atop it, the virtual processor root's removal will NULL out this field indicating
+        // that we are now a free thread.  If there is a virtual processor root, the scheduler still wants to keep the vproc root around and we must
+        // correspondingly act as both a switch out and a deactivate.
+        //
+        if (m_pRoot != NULL)
+        {
+            FreeVirtualProcessorRoot * pRoot = static_cast<FreeVirtualProcessorRoot *>(m_pRoot);
+            if (switchState == Nesting)
+            {
+                // IThreadProxy::SwitchOut can be called with Nesting, if the context tried to InternalContextBase::SwitchTo(NULL, Nesting). Ensure the
+                // root is set to NULL here so the right thing happens with this context/proxy rejoins the scheduler by calling IThreadProxy::SwitchOut(Blocking).
+                m_pRoot = NULL;
+            }
+            (static_cast<FreeVirtualProcessorRoot *>(pRoot))->ResetOnIdle(switchState);
+
+            // If we're nesting, we should return without blocking with the root unchanged. If not, we should have been affinitized to a different root.
+            ASSERT(m_pRoot != NULL || switchState == Nesting);
+        }
+        else
+        {
+            // There are currently only two cases where the m_pRoot field is expected to be NULL.
+            //  - A virtual processor is being retired and the caller invokes SwitchOut to block the thread proxy.
+            //      (root was set to NULL in FreeVirtualProcessorRoot::DeleteThis)
+            //  - A thread proxy that previously switched to a different, nested scheduler, is now joining its original scheduler again.
+            //      (root was set to NULL in FreeThreadProxy::SwitchOut or FreeThreadProxy::SwitchTo)
+            SuspendExecution();
+        }
+    }
+
+    /// <summary>
+    ///     Called right after obtaining a thread proxy from the factory. Associates the thread proxy with the execution
+    ///     context it is about to run.
+    /// </summary>
+    void FreeThreadProxy::AssociateExecutionContext(Concurrency::IExecutionContext * pContext)
+    {
+        m_pContext = pContext;
+        pContext->SetProxy(this);
+    }
+
+    /// <summary>
+    ///     Returns a thread proxy to the factory when it is no longer in use.
+    /// </summary>
+    void FreeThreadProxy::ReturnIdleProxy()
+    {
+        _CONCRT_ASSERT(m_pFactory != NULL);
+        m_pContext = NULL;
+        m_pFactory->ReclaimProxy(this);
+    }
+
+    /// <summary>
+    ///     The main dispatch loop for the free thread proxy.
+    /// </summary>
+    void FreeThreadProxy::Dispatch()
+    {
+        // Send the default dispatch state into Dispatch.
+        DispatchState dispatchState;
+
+        if (!m_fCanceled)
+        {
+            platform::__TlsSetValue(m_pFactory->GetExecutionResourceTls(), (LPVOID) (((size_t) this) | TlsResourceInProxy));
+        }
+
+        while (!m_fCanceled)
+        {
+            _CONCRT_ASSERT(m_pContext != NULL);
+            _CONCRT_ASSERT(m_pRoot != NULL);
+
+            // Call the dispatch loop of the registered context.
+            m_pContext->SetProxy(this);
+            m_pContext->Dispatch(&dispatchState);
+
+            //
+            // The dispatch loop returns when the scheduler that the proxy was given to, has decided to return it back to the RM.
+            // It should be returned to the free proxy factory, so that it can be handed out to a different virtual processor root
+            // (bound to a different context).
+            //
+            // Before doing so, however, we restore the virtual processor to its original state so that it can be activated again.  Note
+            // that if the virtual processor deleted on the way out, m_pRoot is already NULL.  This is only thread which does this and
+            // we are on the same thread.  There is no race.
+            //
+            FreeVirtualProcessorRoot *pRoot = static_cast<FreeVirtualProcessorRoot *>(m_pRoot);
+
+            m_pContext = NULL;
+            m_pRoot = NULL;
+
+            // Return to the idle pool in the RM. If the pool is full, the proxy will be canceled.
+            ReturnIdleProxy();
+
+            if (pRoot != NULL)
+            {
+                pRoot->ResetOnIdle(Blocking);
+            }
+            else
+            {
+                SuspendExecution();
+            }
+        }
+    }
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FreeThreadProxy.h

@@ -0,0 +1,139 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FreeThreadProxy.h
+//
+// Part of the ConcRT Resource Manager -- this header file contains the internal definition for the free thread
+// proxy.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+namespace Concurrency
+{
+namespace details
+{
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class FreeThreadProxy : public ThreadProxy
+    {
+    public:
+
+        /// <summary>
+        ///     Construct a free thread proxy.
+        /// </summary>
+        FreeThreadProxy(IThreadProxyFactory * pFactory, unsigned int stackSize)
+            : ThreadProxy(pFactory, stackSize)
+        { }
+
+        /// <summary>
+        ///     Destroy a free thread proxy.
+        /// </summary>
+        virtual ~FreeThreadProxy()
+        { }
+
+        /// <summary>
+        ///     Called in order to perform a cooperative context switch between one context and another.  After this call, pContext will
+        ///     be running atop the virtual processor root and the context which was running will not.  What happens to the context that
+        ///     was running depends on the value of the reason argument.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context to cooperatively switch to.
+        /// </param>
+        /// <param name="switchState">
+        ///     Indicates the state of the thread proxy that is executing the switch.  This can determine ownership of the underlying thread
+        ///     proxy and context.
+        /// </param>
+        virtual void SwitchTo(::Concurrency::IExecutionContext * pContext, SwitchingProxyState switchState);
+
+        /// <summary>
+        ///     Called in order to disassociate the currently executing context from its virtual processor root, and reinitialize the root
+        ///     for future use.
+        /// </summary>
+        /// <param name="switchState">
+        ///     Indicates the state of the thread proxy that is executing the switch.  This can determine ownership of the underlying thread
+        ///     proxy and context.
+        /// </param>
+        virtual void SwitchOut(SwitchingProxyState switchState = Blocking);
+
+        /// <summary>
+        ///     Called in order to yield to the underlying operating system. This allows the operating system to schedule
+        ///     other work in that time quantum.
+        /// </summary>
+        virtual void YieldToSystem()
+        {
+            platform::__SwitchToThread();
+        }
+
+        /// <summary>
+        ///     Returns the execution context currently attached to the thread proxy.
+        /// </summary>
+        ::Concurrency::IExecutionContext * GetExecutionContext() { return m_pContext; }
+
+        /// <summary>
+        ///     Called right after obtaining a thread proxy from the factory. Associates the thread proxy with the execution
+        ///     context it is about to run.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context to associate with the thread proxy.
+        /// </param>
+        void AssociateExecutionContext(::Concurrency::IExecutionContext * pContext);
+
+        /// <summary>
+        ///     Returns a thread proxy to the factory when it is no longer in use.
+        /// </summary>
+        void ReturnIdleProxy();
+
+        /// <summary>
+        ///     Set the thread affinity to the given affinity
+        /// </summary>
+        /// <param name="newAffinity">
+        ///     The new affinity for the thread
+        /// </param>
+        void SetAffinity(HardwareAffinity newAffinity)
+        {
+            // Set the new affinity only if it is different
+            if (m_previousAffinity != newAffinity)
+            {
+                newAffinity.ApplyTo(GetThreadHandle());
+            }
+
+            m_previousAffinity = newAffinity;
+        }
+
+    private:
+        //
+        // Friend declarations
+        //
+        template <class T> friend class LockFreeStack;
+
+        //
+        // Private member variables
+        //
+
+        // Node affinity
+        HardwareAffinity m_previousAffinity;
+
+        // Entry for freelist
+        SLIST_ENTRY m_slNext{};
+
+        // The context that the thread proxy is running at any time. This is updated when the free proxy is first created, and every time it
+        // is taken from the idle pool and associated with a virtual processor root that was handed to a scheduler. A free thread proxy
+        // is only associated with one context at a time.
+        ::Concurrency::IExecutionContext * m_pContext{};
+
+        //
+        // Private member functions
+        //
+
+        /// <summary>
+        ///     The main dispatch routine for a free thread proxy
+        /// </summary>
+        virtual void Dispatch();
+    };
+#pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FreeVirtualProcessorRoot.cpp

@@ -0,0 +1,347 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FreeVirtualProcessorRoot.cpp
+//
+// Part of the ConcRT Resource Manager -- this header file contains the internal implementation for the free virtual
+// processor root (represents a virtual processor as handed to a scheduler).
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+
+    /// <summary>
+    ///     Constructs a new free virtual processor root.
+    /// </summary>
+    /// <param name="pSchedulerProxy">
+    ///     The scheduler proxy this root is created for. A scheduler proxy holds RM data associated with an instance of
+    ///     a scheduler.
+    /// </param>
+    /// <param name="pNode">
+    ///     The processor node that this root belongs to. The processor node is one among the nodes allocated to the
+    ///     scheduler proxy.
+    /// </param>
+    /// <param name="coreIndex">
+    ///     The index into the array of cores for the processor node specified.
+    /// </param>
+    FreeVirtualProcessorRoot::FreeVirtualProcessorRoot(SchedulerProxy *pSchedulerProxy, SchedulerNode* pNode, unsigned int coreIndex)
+        : VirtualProcessorRoot(pSchedulerProxy, pNode, coreIndex),
+        m_pExecutingProxy(NULL),
+        m_pDeactivatedProxy(NULL)
+    {
+    }
+
+    /// <summary>
+    ///     Deletes the virtual processor.
+    /// </summary>
+    void FreeVirtualProcessorRoot::DeleteThis()
+    {
+        //
+        // This comes in via a Remove() call on one of two threads:
+        //
+        //     - The thread that is running the virtual processor root.
+        //           - There can be no race.  We just need to make sure that the thread on exit doesn't touch us after deletion.
+        //
+        //     - An arbitrary thread.
+        //           - We need to be careful that we aren't racing between that thread's getting out (SwitchOut followed by returning from
+        //             the context's dispatch loop), and it trying to reset the vproc root in ResetOnIdle.  We must spin until that has happened.
+        //
+        FreeThreadProxy *pCurrentProxy = NULL;
+
+        DWORD tlsSlot = GetSchedulerProxy()->GetResourceManager()->GetExecutionResourceTls();
+        void * tlsPointer = platform::__TlsGetValue(tlsSlot);
+        size_t tlsValue = (size_t) tlsPointer;
+
+        if (tlsPointer != NULL && ((tlsValue & TlsResourceBitMask) == TlsResourceInProxy))
+            pCurrentProxy = (FreeThreadProxy *) (tlsValue & ~TlsResourceInProxy);
+
+        if (pCurrentProxy != NULL && pCurrentProxy == m_pExecutingProxy)
+        {
+            pCurrentProxy->SetVirtualProcessorRoot(NULL);
+        }
+        else
+        {
+            //
+            // Spin wait until there isn't anything running atop this virtual processor root.  Yes -- this means that someone had better be
+            // on the way out.  If you call Remove on a virtual processor that's still running something, the resulting behavior is pretty much
+            // undefined anyway.
+            //
+            SpinUntilIdle();
+        }
+
+        delete this;
+    }
+
+    /// <summary>
+    ///     Called in order to reset this virtual processor root to a completely quiescent state (not running anything).
+    /// </summary>
+    /// <param name="switchState">
+    ///     Indicates the state of the thread proxy that is making the call. The parameter is of type <typeparamref name="SwitchingProxyState"/>.
+    /// </param>
+    void FreeVirtualProcessorRoot::ResetOnIdle(SwitchingProxyState switchState)
+    {
+        FreeThreadProxy *pOriginalProxy = static_cast<FreeThreadProxy *>(m_pExecutingProxy);
+
+        LONG newVal = InterlockedDecrement(&m_activationFence);
+        if (newVal <= 0)
+        {
+            //
+            // The value could be -1 if we raced with the virtual processor root being removed on a different thread.
+            //
+            ASSERT(newVal >= -1);
+            //
+            // The fence going down to zero arbitrates between a possible reset/remove race.
+            //
+            if (newVal == 0)
+                Unsubscribe();
+
+            m_pExecutingProxy = NULL;
+
+            //
+            // *** READ THIS ***:
+            //
+            // It is imperative on this path that once m_pExecutingProxy has been set to NULL, nothing touches the this pointer.  We are the race
+            // resolution between a client getting off a vproc and removing it.  There can be a race between removal (DeleteThis) from outside and
+            // a SwitchOut (here) on the vproc.
+            //
+            if (switchState == Blocking)
+            {
+                pOriginalProxy->SuspendExecution();
+            }
+        }
+        else
+        {
+            Concurrency::IExecutionContext *pActivatedContext = AcquireActivatedContext();
+            ASSERT(newVal == 1 && pActivatedContext != NULL);
+
+            //
+            // This means we had a race between an Activate and an Idling (via either SwitchOut or return from dispatch loop).  In either
+            // of these cases, we stashed away the context which was activated in m_pActivatedContext.  This context now needs to run atop us.
+            //
+            FreeThreadProxy *pProxy = static_cast<FreeThreadProxy *> (pActivatedContext->GetProxy());
+            ASSERT(pProxy != NULL);
+
+            //
+            // While it is safe to run through an X->X context switch after the blocked flag is set, there is no point.  If we raced a SwitchOut/Activate
+            // for the same proxy on the same vproc, it's a NOP.
+            //
+            if (pOriginalProxy != pProxy)
+            {
+                pOriginalProxy->SwitchTo(pActivatedContext, switchState);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Causes the scheduler to start running a thread proxy on the specified virtual processor root which will execute
+    ///     the Dispatch method of the context supplied by pContext. Alternatively, it can be used to resume a
+    ///     virtual processor root that was de-activated by a previous call to Deactivate.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context which will be dispatched on a (potentially) new thread running atop this virtual processor root.
+    /// </param>
+    void FreeVirtualProcessorRoot::Activate(Concurrency::IExecutionContext *pContext)
+    {
+        if (pContext == NULL)
+            throw std::invalid_argument("pContext");
+
+        //
+        // If the context is being reused, it had better return a NULL thread proxy when we ask!  This is part of the spec contract.
+        //
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *> (pContext->GetProxy());
+        if (pProxy == NULL)
+        {
+            pProxy = static_cast<FreeThreadProxy *> (GetSchedulerProxy()->GetNewThreadProxy(pContext));
+        }
+
+        //
+        // All calls to Activate after the first one can potentially race with the paired deactivate. This is allowed by the API, and we use the fence below
+        // to reduce kernel transitions in case of this race.
+        //
+        // We must also be careful because calls to activate can race with ResetOnIdle from either a SwitchOut() or a return from dispatch and we must
+        // be prepared to deal with this and the implications around trying to bind pContext.
+        //
+        LONG newVal = InterlockedIncrement(&m_activationFence);
+        if (newVal == 2)
+        {
+            ASSERT(m_pDeactivatedProxy == NULL);
+            //
+            // We received two activations in a row. According to the contract with the client, this is allowed, but we should expect a deactivation, a
+            // SwitchOut, or a return from dispatch loop soon after.
+            //
+            // Simply return instead of signalling the event. The deactivation will reduce the count back to 1. In addition, we're not responsible
+            // for changing the idle state on the core.
+            //
+            SetActivatedContext(pContext);
+        }
+        else
+        {
+            ASSERT(newVal == 1);
+
+            SpinUntilIdle();
+            ASSERT(m_pExecutingProxy == m_pDeactivatedProxy);
+
+            if (m_pExecutingProxy != NULL)
+            {
+                //
+                // The root already has an associated thread proxy.  Check that the context provided is associated with
+                // the same proxy.
+                //
+                if (pProxy != m_pExecutingProxy)
+                {
+                    //
+                    // This is a fatal exception.  We can potentially correct the state of the fence, but the scheduler is beyond confused about
+                    // the spec.  @TODO: Is it worth making some attempt to correct *our* state given that it's already messed up above us?
+                    //
+                    throw invalid_operation();
+                }
+            }
+
+            m_pDeactivatedProxy = NULL;
+
+            //
+            // An activated root increases the subscription level on the underlying core.
+            //
+            Subscribe();
+
+            //
+            // Affinitization sets this as the executing proxy for the virtual processor root.
+            //
+            Affinitize(pProxy);
+
+            ASSERT(m_pExecutingProxy == pProxy);
+            ASSERT(pProxy->GetVirtualProcessorRoot() != NULL);
+            ASSERT(pProxy->GetExecutionContext() != NULL);
+
+            pProxy->ResumeExecution();
+        }
+    }
+
+    /// <summary>
+    ///     Causes the thread proxy running atop this virtual processor root to temporarily stop dispatching pContext.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context which should temporarily stop being dispatched by the thread proxy running atop this virtual processor root.
+    /// </param>
+    bool FreeVirtualProcessorRoot::Deactivate(Concurrency::IExecutionContext *pContext)
+    {
+        if (pContext == NULL)
+            throw std::invalid_argument("pContext");
+
+        if (m_pExecutingProxy == NULL)
+            throw invalid_operation();
+
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *> (pContext->GetProxy());
+
+        if (m_pExecutingProxy != pProxy)
+        {
+            throw invalid_operation();
+        }
+
+        LONG newVal = InterlockedDecrement(&m_activationFence);
+
+        if (newVal == 0)
+        {
+            //
+            // Reduce the subscription level on the core while the root is suspended. The count is used by dynamic resource management
+            // to tell which cores allocated to a scheduler are unused, so that they can be temporarily repurposed.
+            //
+            InterlockedExchangePointer(reinterpret_cast<void * volatile *>(&m_pDeactivatedProxy), m_pExecutingProxy);
+            Unsubscribe();
+            pProxy->SuspendExecution();
+        }
+        else
+        {
+            //
+            // There should be no Deactivate/Remove races.
+            //
+            ASSERT(newVal == 1);
+
+            Concurrency::IExecutionContext *pActivatedContext = AcquireActivatedContext();
+
+            //
+            // If we got here, it means while activated we saw an activation of pCtxX and a subsequent deactivation of pCtxY.  These contexts
+            // must be equal to be spec legal.
+            //
+            ASSERT(pActivatedContext == pContext);
+
+            //
+            // The activation for this deactivation came in early, so we return early here without making a kernel transition.
+            //
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Forces all data in the memory heirarchy of one processor to be visible to all other processors.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context which is currently being dispatched by this root.
+    /// </param>
+    void FreeVirtualProcessorRoot::EnsureAllTasksVisible(Concurrency::IExecutionContext *pContext)
+    {
+        if (pContext == NULL)
+            throw std::invalid_argument("pContext");
+
+        if (m_pExecutingProxy == NULL)
+            throw invalid_operation();
+
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *> (pContext->GetProxy());
+
+        if (m_pExecutingProxy != pProxy)
+        {
+            throw invalid_operation();
+        }
+
+        GetSchedulerProxy()->GetResourceManager()->FlushStoreBuffers();
+    }
+
+    /// <summary>
+    ///     Called to affinitize the given thread proxy to this virtual processor.
+    /// </summary>
+    /// <param name="pThreadProxy">
+    ///     The new thread proxy to run atop this virtual processor root.
+    /// </param>
+    void FreeVirtualProcessorRoot::Affinitize(FreeThreadProxy *pThreadProxy)
+    {
+        //
+        // Wait until the thread proxy is firmly blocked. This is essential to prevent vproc root orphanage
+        // if the thread proxy we're switching to is IN THE PROCESS of switching out to a different one. An example of how this
+        // could happen:
+
+        // 1] ctxA is running on vp1. It is in the process of blocking, and wants to switch to ctxB. This means ctxA's thread proxy
+        // tpA must affinitize ctxB's thread proxy tpB to its own vproc root, vproot1.
+
+        // 2] At the exact same time, ctxA is unblocked by ctxY and put onto a runnables collection in its scheduler. Meanwhile, ctxZ
+        // executing on vp2, has also decided to block. It picks ctxA off the runnables collection, and proceeds to switch to it.
+        // This means that ctxZ's thread proxy tpZ must affinitize ctxA's thread proxy tpA to ITS vproc root vproot2.
+
+        // 3] Now, if tpZ affinitizes tpA to vproot2 BEFORE tpA has had a chance to affinitize tpB to vproot1, tpB gets mistakenly
+        // affinitized to vproot2, and vproot1 is orphaned.
+
+        // In order to prevent this, tpZ MUST wait until AFTER tpA has finished its affinitization. This is indicated via the
+        // blocked flag. tpA will set its blocked flag to 1, after it has finished affintizing tpB to vproot1, at which point it is
+        // safe for tpZ to modify tpA's vproc root and change it from vproot1 to vproot2.
+        //
+
+        pThreadProxy->SpinUntilBlocked();
+
+        m_pExecutingProxy = pThreadProxy;
+        pThreadProxy->SetVirtualProcessorRoot(this);
+
+        HardwareAffinity newAffinity = GetSchedulerProxy()->GetNodeAffinity(GetNodeId());
+        pThreadProxy->SetAffinity(newAffinity);
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/FreeVirtualProcessorRoot.h

@@ -0,0 +1,112 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// FreeVirtualProcessorRoot.h
+//
+// Part of the ConcRT Resource Manager -- this header file contains the internal definition for the free virtual
+// processor root (represents a virtual processor as handed to a scheduler).
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+namespace Concurrency
+{
+namespace details
+{
+
+    class FreeVirtualProcessorRoot : public VirtualProcessorRoot
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a new free virtual processor root.
+        /// </summary>
+        /// <param name="pSchedulerProxy">
+        ///     The scheduler proxy this root is created for. A scheduler proxy holds RM data associated with an instance of
+        ///     a scheduler.
+        /// </param>
+        /// <param name="pNode">
+        ///     The processor node that this root belongs to. The processor node is one among the nodes allocated to the
+        ///     scheduler proxy.
+        /// </param>
+        /// <param name="coreIndex">
+        ///     The index into the array of cores for the processor node specified.
+        /// </param>
+        FreeVirtualProcessorRoot(SchedulerProxy *pSchedulerProxy, SchedulerNode* pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Causes the scheduler to start running a thread proxy on the specified virtual processor root which will execute
+        ///     the Dispatch method of the context supplied by pContext.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context which will be dispatched on a (potentially) new thread running atop this virtual processor root.
+        /// </param>
+        virtual void Activate(::Concurrency::IExecutionContext *pContext);
+
+        /// <summary>
+        ///     Causes the thread proxy running atop this virtual processor root to temporarily stop dispatching pContext.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context which should temporarily stop being dispatched by the thread proxy running atop this virtual processor root.
+        /// </param>
+        virtual bool Deactivate(::Concurrency::IExecutionContext *pContext);
+
+        /// <summary>
+        ///     Forces all data in the memory heirarchy of one processor to be visible to all other processors.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context which is currently being dispatched by this root.
+        /// </param>
+        virtual void EnsureAllTasksVisible(::Concurrency::IExecutionContext *pContext);
+
+        // **************************************************
+        // Internal
+        // **************************************************
+
+        /// <summary>
+        ///     Deletes the virtual processor.
+        /// </summary>
+        virtual void DeleteThis();
+
+        /// <summary>
+        ///     Called to affinitize the given thread proxy to this virtual processor.
+        /// </summary>
+        /// <param name="pThreadProxy">
+        ///     The new thread proxy to run atop this virtual processor root.
+        /// </param>
+        void Affinitize(FreeThreadProxy *pThreadProxy);
+
+        /// <summary>
+        ///     Called in order to reset this virtual processor root to a completely quiescent state (not running anything).
+        /// </summary>
+        /// <param name="switchState">
+        ///     Indicates the state of the thread proxy that is making the call. The parameter is of type <typeparamref name="SwitchingProxyState"/>.
+        /// </param>
+        void ResetOnIdle(SwitchingProxyState switchState);
+
+    protected:
+
+        /// <summary>
+        ///     Spins until there is no thread proxy executing atop the virtual processor root.
+        /// </summary>
+        void SpinUntilIdle()
+        {
+            _SpinWaitBackoffNone spinWait(_Sleep0);
+            while(m_pExecutingProxy != NULL && m_pDeactivatedProxy == NULL)
+            {
+                spinWait._SpinOnce();
+            }
+        }
+
+        // The thread proxy which is currently executing atop this virtual processor root.
+        ThreadProxy * volatile m_pExecutingProxy;
+
+        // The deactivated proxy.
+        ThreadProxy * volatile m_pDeactivatedProxy;
+
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/HillClimbing.cpp

@@ -0,0 +1,892 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// HillClimbing.cpp
+//
+// Defines classes for the HillClimbing concurrency-optimization algorithm.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+#include <math.h>
+
+#pragma warning(disable:4389)
+
+namespace Concurrency
+{
+namespace details
+{
+    //
+    // Initial hill climbing configuration settings. These are the starting points for any hill climbing instance.
+    //
+    static const unsigned int AlwaysIncrease = 0;            // Test setting for always allocating more resources
+    static const unsigned int ControlGain = 1;               // Used to determine the magnitude of moves, in units of (coefficient of variation)/(thread count)
+    static const unsigned int MaxControlSettingChange = 0;   // Maximum number of resources that can be changed in one transition (i.e. a capper)
+    static const unsigned int MinHistorySize = 3;            // Minimum history size to consider relevant for climbing (used for significance test)
+    static const unsigned int MaxHistorySize = 5;            // Maximum history size, after which a climbing move must be recommended
+    static const unsigned int WarmupSampleCount = 1;         // How many samples are needed to warm up hill climbing
+    static const unsigned int MinCompletionsPerSample = 1;   // Minimum number of completions needed to try hill climbing
+    static const unsigned int MaxInvalidCount = 3;           // Maximum number of consecutive invalid samples; minimum recommended after this point
+    static const unsigned int MaxHistoryAge = 50;            // Maximum amount of ticks to keep a history from a previous setting
+
+    /// <summary>
+    ///     Creates a new instance of hill climbing.
+    /// </summary>
+    /// <param name="id">
+    ///     Scheduler id.
+    /// </param>
+    /// <param name="numberOfCores">
+    ///     Number that represents the maximum resources available on the machine.
+    /// </param>
+    /// <param name="pSchedulerProxy">
+    ///     The scheduler proxy that controls this hill climbing instance.
+    /// </param>
+    HillClimbing::HillClimbing(unsigned int id, unsigned int numberOfCores, SchedulerProxy * pSchedulerProxy)
+        : m_pSchedulerProxy(pSchedulerProxy)
+        , m_currentControlSetting(0)
+        , m_lastControlSetting(0)
+        , m_id(id)
+        , m_sampleCount(0)
+        , m_totalSampleCount(0)
+        , m_invalidCount(0)
+        , m_saveCompleted(0)
+        , m_saveIncoming(0)
+        , m_nextRandomMoveIsUp(true)
+    {
+        //
+        // Assign default configuration
+        //
+        m_controlGain = ControlGain * numberOfCores;
+        m_maxControlSettingChange = (MaxControlSettingChange != 0) ? MaxControlSettingChange : numberOfCores;
+    }
+
+    /// <summary>
+    ///     External call passing statistical information to hill climbing. Based on these
+    ///     statistics, hill climbing will give a recommendation on the number of resources to be used.
+    /// </summary>
+    /// <param name="currentControlSetting">
+    ///     The control setting used in this period of time.
+    /// </param>
+    /// <param name="completionRate">
+    ///     The number of completed units or work in that period of time.
+    /// </param>
+    /// <param name="arrivalRate">
+    ///     The number of incoming units or work in that period of time.
+    /// </param>
+    /// <param name="queueLength">
+    ///     The total length of the work queue.
+    /// </param>
+    /// <returns>
+    ///     The recommended number of resources to be used.
+    /// </returns>
+    unsigned int HillClimbing::Update(unsigned int currentControlSetting, unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength)
+    {
+        HillClimbingStateTransition transition = Undefined;
+        int recommendedSetting = 0;
+
+        // If there are no resources devoted to this scheduler proxy then there is
+        // no statistical analysis needed.
+        if (currentControlSetting == 0)
+        {
+            return 0;
+        }
+
+        //
+        // Hill climbing made a recommendation for a number of resources to be used the next time around. However, that
+        // does not mean that this recommendation was accepted by the consumer of that information. Thus, first establish
+        // the control setting passed in by the consumer so that we can accurately track history information. Also, it is
+        // necessary to flush old, stale history information before trying to hill climb.
+        //
+        m_totalSampleCount++;
+        EstablishControlSetting(currentControlSetting);
+
+        //
+        // If we had some invalid samples, then carefully modify the actual parameters to this function
+        //
+        if (m_invalidCount > 0)
+        {
+            completionRate += m_saveCompleted;
+            arrivalRate += m_saveIncoming;
+        }
+
+        //
+        // If we have long running tasks that are not yet completed, report completions and arrivals for those
+        // tasks, effectively chunking them up into sample sized tasks. A long running task scenario is defined as:
+        //
+        //  a) Number or completed tasks is smaller than number of resources used in the time interval, AND
+        //  b) Number of completed tasks is smaller than a length of the queue (resources cannot be invalid)
+        //
+        if (completionRate < currentControlSetting && completionRate < queueLength)
+        {
+            arrivalRate += (currentControlSetting - completionRate);
+            completionRate = currentControlSetting;
+        }
+
+        //
+        // Check if reported statistics are within the bounds of a valid sample. A sample is invalid iff:
+        // it is not a warmup run AND it is EITHER too short of a measurement OR there were not enough completions.
+        //
+        if (m_sampleCount >= WarmupSampleCount && MinCompletionsPerSample > completionRate && MinCompletionsPerSample > arrivalRate && queueLength == 0)
+        {
+            //
+            // If this is an invalid sample, save the data
+            //
+            m_invalidCount++;
+            m_saveCompleted = completionRate;
+            m_saveIncoming = arrivalRate;
+
+            unsigned int minimumSetting = m_pSchedulerProxy->MinHWThreads();
+            unsigned int maximumSetting = m_pSchedulerProxy->DesiredHWThreads();
+            (maximumSetting);
+
+            recommendedSetting = (m_invalidCount < MaxInvalidCount) ? m_currentControlSetting : minimumSetting;
+
+            TRACE(CONCRT_TRACE_HILLCLIMBING,
+                L"********** Invalid sample!\n Process: %u\n Scheduler: %d\n Invalid count: %d\n Completions: %d\n Arrivals: %d\n Queue length: %d\n Minimum: %d\n Maximum: %d\n Current setting: %d\n Last setting: %d\n -----\n Recommended setting: %d\n**********\n",
+                GetCurrentProcessId(),
+                m_id,
+                m_invalidCount,
+                completionRate,
+                arrivalRate,
+                queueLength,
+                minimumSetting,
+                maximumSetting,
+                m_currentControlSetting,
+                m_lastControlSetting,
+                recommendedSetting);
+
+            return recommendedSetting;
+        }
+
+        unsigned int numberOfSamples = m_invalidCount + 1;
+
+        //
+        // Reset the statistics kept for invalid samples and initiate a valid sample
+        //
+        m_sampleCount++;
+        m_saveCompleted = 0;
+        m_saveIncoming = 0;
+        m_invalidCount = 0;
+
+        // Unless there is a good reason to climb, the current setting (set by EstablishControlSetting) will remain the same.
+        recommendedSetting = m_currentControlSetting;
+
+        // Calculate the throughput for this given instance
+        double throughput = CalculateThroughput(numberOfSamples, completionRate, arrivalRate, queueLength);
+
+        if (m_sampleCount <= WarmupSampleCount)
+        {
+            //
+            // We're in the "warmup" phase, where we simply bide our time (and initialize our current control setting).
+            //
+            _CONCRT_ASSERT(m_currentControlSetting != 0);
+            m_lastControlSetting = m_currentControlSetting;
+            transition = Warmup;
+        }
+        else
+        {
+            MeasuredHistory * currentHistory = GetHistory(m_currentControlSetting);
+            MeasuredHistory * lastHistory = GetHistory(m_lastControlSetting);
+
+            currentHistory->Add(throughput, m_totalSampleCount);
+
+            if (AlwaysIncrease > 0)
+            {
+                //
+                // We're in the "always increase" diagnostic mode.  Just increase the control setting
+                // along the desired gradient.
+                //
+                unsigned int newSetting = (unsigned int) ((AlwaysIncrease / 1000.0) * m_sampleCount);
+
+                if (newSetting > m_currentControlSetting)
+                {
+                    recommendedSetting = RecommendControlSetting(newSetting);
+                    transition = DoClimbing;
+                }
+                else
+                {
+                    transition = ContinueLookingForClimb;
+                }
+            }
+            else if (lastHistory->Count() == 0 || currentHistory == lastHistory)
+            {
+                //
+                // If we have no previous history, then we need to initialize.  We wait until
+                // the current history is stable, then make our first move.
+                //
+                if (IsStableHistory(currentHistory))
+                {
+                    //
+                    // This is our first move; we have no history to use to predict the correct move.
+                    // We'll just make a random move, and see what happens.
+                    //
+                    recommendedSetting = RecommendControlSetting(m_currentControlSetting + GetRandomMove());
+                    transition = CompletedInitialization;
+                }
+                else
+                {
+                    transition = ContinueInitializing;
+                }
+            }
+            else if (!IsStableHistory(currentHistory))
+            {
+                transition = ContinueLookingForClimb;
+            }
+            else
+            {
+                //
+                // We have two separate stable histories.  We can compare them, and make a real climbing move.
+                //
+                double gradient = CalculateThroughputGradient(m_lastControlSetting, m_currentControlSetting);
+                double controlSettingAdjustment = gradient * m_controlGain;
+                unsigned int newControlSetting = (unsigned int) (m_currentControlSetting + controlSettingAdjustment);
+
+                if (newControlSetting == m_currentControlSetting)
+                {
+                    newControlSetting = (unsigned int) (m_currentControlSetting + sign(controlSettingAdjustment));
+                }
+
+                recommendedSetting = RecommendControlSetting(newControlSetting);
+                transition = DoClimbing;
+            }
+        }
+
+        _CONCRT_ASSERT(transition != Undefined); // Unhandled case for HillClimbing controller
+
+#if defined(CONCRT_TRACING)
+        LogData(recommendedSetting, transition, numberOfSamples, completionRate, arrivalRate, queueLength, throughput);
+#endif
+
+        return recommendedSetting;
+    }
+
+    /// <summary>
+    ///     Calculates the throughput based on the input parameters.
+    /// </summary>
+    /// <param name="numberOfSamples">
+    ///     The number of sample points in this measurement, including invalid ones.
+    /// </param>
+    /// <param name="completionRate">
+    ///     The number of completed units or work in that period of time.
+    /// </param>
+    /// <param name="arrivalRate">
+    ///     The number of incoming units or work in that period of time.
+    /// </param>
+    /// <param name="queueLength">
+    ///     The total length of the work queue.
+    /// </param>
+    /// <returns>
+    ///     The calculated throughput.
+    /// </returns>
+    double HillClimbing::CalculateThroughput(unsigned int numberOfSamples, unsigned int completionRate, unsigned int, unsigned int)
+    {
+        const double samplesPerSecond = 10.0;    // A double constant representing number of valid samples per second
+
+        // Compute the rate at which the queue is growing or shrinking. If it is growing, report a higher
+        // number which will cause more resources to be allocated for this instance; it the length of the queue
+        // is shrinking, try to take away resources while still shrinking the queue.
+        //
+        //           /_\ length     incoming - completed
+        // growth = ------------ = ----------------------
+        //            /_\ time            t2 - t1
+        //
+        // For now, instead of looking at the change in the queue length, completion rate will be used. This is due
+        // to the fact that typical loads in ConcRT are self-balancing, i.e. completion rate ~ incoming rate.
+        //
+        return (completionRate * samplesPerSecond) / (double) (numberOfSamples);
+    }
+
+    /// <summary>
+    ///     Recommends NewControlSetting to be used.
+    /// </summary>
+    /// <param name="newControlSetting">
+    ///     The control setting to be established.
+    /// </param>
+    /// <returns>
+    ///     New control setting to be used.
+    /// </returns>
+    unsigned int HillClimbing::RecommendControlSetting(unsigned int newControlSetting)
+    {
+        //
+        // Make sure that the new setting is within the biggest individual move bounds.
+        //
+        unsigned int minimumSetting = m_pSchedulerProxy->MinHWThreads();
+        unsigned int maximumSetting = m_pSchedulerProxy->DesiredHWThreads();
+
+        newControlSetting = min(m_currentControlSetting + m_maxControlSettingChange, newControlSetting);
+
+        if (m_currentControlSetting > m_maxControlSettingChange)
+        {
+            newControlSetting = max(m_currentControlSetting - m_maxControlSettingChange, newControlSetting);
+        }
+
+        if (newControlSetting == m_currentControlSetting)  // Can't draw a line with a single point
+        {
+            if (newControlSetting > minimumSetting)
+            {
+                newControlSetting--;
+            }
+            else
+            {
+                newControlSetting++;
+            }
+        }
+
+        //
+        // Make sure that the new setting is within the min and max bounds of the scheduler proxy.
+        //
+        newControlSetting = max(minimumSetting, newControlSetting);
+        newControlSetting = min(maximumSetting, newControlSetting);
+
+        if (AlwaysIncrease == 0 && newControlSetting != m_currentControlSetting)
+        {
+            // If this move would cause us to move through a setting that we know was recently worse than this
+            // one, then back off to one before that setting.
+            int direction = sign(newControlSetting - m_currentControlSetting);
+
+            if (direction == -1)
+            {
+                for (int setting = m_currentControlSetting + direction;
+                     setting == newControlSetting || sign(newControlSetting - setting) == direction;
+                     setting += direction)
+                {
+                    if (GetHistory(setting)->Count() > 0)
+                    {
+                        double gradient = CalculateThroughputGradient(m_currentControlSetting, setting) * direction;
+
+                        if (gradient <= 0)
+                        {
+                            newControlSetting = setting - direction;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return newControlSetting;
+    }
+
+    /// <summary>
+    ///     Establishes control setting as current. This is the only method that updates the control settings.
+    /// </summary>
+    /// <param name="newControlSetting">
+    ///     The control setting to be established.
+    /// </param>
+    void HillClimbing::EstablishControlSetting(unsigned int newControlSetting)
+    {
+        if (newControlSetting != m_currentControlSetting)
+        {
+            m_lastControlSetting = m_currentControlSetting;
+            m_currentControlSetting = newControlSetting;
+            GetHistory(m_currentControlSetting)->Clear(0);
+            FlushHistories();
+        }
+    }
+
+    /// <summary>
+    ///     Calculates the throughput gradient given two history measurements.
+    /// </summary>
+    /// <param name="fromSetting">
+    ///     The control setting to move from.
+    /// </param>
+    /// <param name="toSetting">
+    ///     The control setting to move to.
+    /// </param>
+    /// <returns>
+    ///     A value representing a gradient between two measurements.
+    /// </returns>
+    double HillClimbing::CalculateThroughputGradient(int fromSetting, int toSetting)
+    {
+        //
+        // Configurable constants to control reactiveness of hill climbing
+        //
+        const double minJustifiesChange = 0.15;         // A minimum fractional change in measurement that justifies a change (cost for making a change)
+        const double changeAdjustmentMultiplier = 1.0;  // Controls change factor by reducing uncertainty (bigger number pessimizes change frequency)
+
+        double fractionalChangeInControlSetting = (double) (toSetting - fromSetting) / (double) fromSetting;
+
+        MeasuredHistory * lastHistory = GetHistory(fromSetting);
+        MeasuredHistory * currentHistory = GetHistory(toSetting);
+
+        double lastHistoryMean = lastHistory->Mean();
+        double currentHistoryMean = currentHistory->Mean();
+        double meanChangeInMeasuredValue = currentHistoryMean - lastHistoryMean;
+        double fractionalChangeInMeasuredValue = meanChangeInMeasuredValue / lastHistoryMean;
+
+        double gradient = (fractionalChangeInMeasuredValue/fractionalChangeInControlSetting) - minJustifiesChange;
+
+        double varianceOfcurrentHistory = currentHistory->VarianceMean();
+        double varianceOflastHistory = lastHistory->VarianceMean();
+        double standardDeviationOfDifferenceInMeans = sqrt(varianceOfcurrentHistory + varianceOflastHistory);
+        double coefficientOfVariationOfChangeInMeasuredValue =
+            (abs(meanChangeInMeasuredValue) > 0) ? abs(standardDeviationOfDifferenceInMeans / meanChangeInMeasuredValue) : 0;
+
+        double adjustedGradient = gradient * exp(-changeAdjustmentMultiplier * coefficientOfVariationOfChangeInMeasuredValue);
+
+        return adjustedGradient;
+    }
+
+    /// <summary>
+    ///     Determines whether a given history measurement is stable enough to make a hill climbing move.
+    /// </summary>
+    /// <returns>
+    ///     True if history measurement is stable.
+    /// </returns>
+    bool HillClimbing::IsStableHistory(MeasuredHistory * pMeasuredHistory)
+    {
+        const double maxCoefficientOfVariation = 0.004; // Controls history relevance between min and max by bounding the error
+
+        if (pMeasuredHistory->Count() > MaxHistorySize)
+        {
+            return true;
+        }
+
+        if (pMeasuredHistory->Count() < MinHistorySize)
+        {
+            return false;
+        }
+
+        if (abs(pMeasuredHistory->CoefficientOfVariationMean()) > maxCoefficientOfVariation)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Flushes all measurement histories that are no longer relevant.
+    /// </summary>
+    void HillClimbing::FlushHistories()
+    {
+        for (int i = 0; i < MaxHistoryCount; i++)
+        {
+            if (m_histories[i].ControlSetting() != m_currentControlSetting &&
+                m_histories[i].ControlSetting() != m_lastControlSetting &&
+                m_totalSampleCount - m_histories[i].LastDataPointCount() > MaxHistoryAge)
+            {
+                m_histories[i].Clear(0);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Clears all measurement histories.
+    /// </summary>
+    void HillClimbing::ClearHistories()
+    {
+        for (int i = 0; i < MaxHistoryCount; i++)
+        {
+            m_histories[i].Clear(0);
+        }
+    }
+
+    /// <summary>
+    ///     Makes a pseudo-random hill climbing move by alternating between up and down.
+    /// </summary>
+    /// <returns>
+    ///     The random move.
+    /// </returns>
+    int HillClimbing::GetRandomMove()
+    {
+        int result = m_nextRandomMoveIsUp ? 1 : 0;
+        m_nextRandomMoveIsUp = !m_nextRandomMoveIsUp;
+        return result;
+    }
+
+    /// <summary>
+    ///     Gets the history measurement for a given control setting.
+    /// </summary>
+    /// <returns>
+    ///     The history measurement.
+    /// </returns>
+    HillClimbing::MeasuredHistory * HillClimbing::GetHistory(unsigned int controlSetting)
+    {
+        int i = controlSetting % MaxHistoryCount;
+
+        if (m_histories[i].ControlSetting() != controlSetting)
+        {
+            m_histories[i].Clear(controlSetting);
+        }
+
+        return &m_histories[i];
+    }
+
+    /// <summary>
+    ///     Creates a new measurement history.
+    /// </summary>
+    HillClimbing::MeasuredHistory::MeasuredHistory()
+    {
+        Clear(0);
+    }
+
+    /// <summary>
+    ///     Clears the history values for this control setting.
+    /// </summary>
+    /// <param name="controlSetting">
+    ///     The control setting to reset.
+    /// </param>
+    void HillClimbing::MeasuredHistory::Clear(unsigned int controlSetting)
+    {
+        m_count = 0;
+        m_sum = 0;
+        m_sumOfSquares = 0;
+        m_controlSetting = controlSetting;
+        m_lastDataPointCount = 0;
+    }
+
+    /// <summary>
+    ///     Adds a new history data point.
+    /// </summary>
+    /// <param name="dataValue">
+    ///     The value representing throughput in this invocation.
+    /// </param>
+    /// <param name="totalSampleCount">
+    ///     The value representing the total number of samples for this history, including invalid samples and samples for previous settings.
+    /// </param>
+    void HillClimbing::MeasuredHistory::Add(const double dataValue, unsigned int totalSampleCount)
+    {
+        m_sum += dataValue;
+        m_sumOfSquares += dataValue * dataValue;
+        m_count++;
+        m_lastDataPointCount = totalSampleCount;
+    }
+
+    /// <summary>
+    ///     Gets the count for this history measurement.
+    /// </summary>
+    /// <returns>
+    ///     The count.
+    /// </returns>
+    int HillClimbing::MeasuredHistory::Count()
+    {
+        return m_count;
+    }
+
+    /// <summary>
+    ///     Gets the count at the last data point for this history measurement.
+    /// </summary>
+    /// <returns>
+    ///     The last data point count.
+    /// </returns>
+    unsigned int HillClimbing::MeasuredHistory::LastDataPointCount()
+    {
+        return m_lastDataPointCount;
+    }
+
+    /// <summary>
+    ///     Gets the control setting for this history measurement.
+    /// </summary>
+    /// <returns>
+    ///     The control setting.
+    /// </returns>
+    int HillClimbing::MeasuredHistory::ControlSetting() {
+        return m_controlSetting;
+    }
+
+    /// <summary>
+    ///     Computes the mean for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The mean.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::Mean()
+    {
+        return (m_count == 0) ? 0.0 : (m_sum / m_count);
+    }
+
+    /// <summary>
+    ///     Computes the coefficient of variation for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The coefficient of variation.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::CoefficientOfVariation()
+    {
+        double mean = Mean();
+        return (mean <= 0.0) ? 0.0 : (StandardDeviation() / mean);
+    }
+
+    /// <summary>
+    ///     Computes the mean of coefficients of variation for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The mean of coefficients of variation.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::CoefficientOfVariationMean()
+    {
+        return (StandardDeviation() / sqrt(1.0 * m_count)) / Mean();
+    }
+
+    /// <summary>
+    ///     Computes the variance for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The variance.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::Variance()
+    {
+        const double smallValue = 0.0001;
+        double variance = 0.0;
+
+        if (m_count >= 2)
+        {
+            variance = (m_sumOfSquares - (m_sum * m_sum)/ m_count)/ (m_count - 1);
+        }
+
+        return abs(variance) > smallValue ? variance : 0;
+    }
+
+    /// <summary>
+    ///     Computes the mean of variances for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The mean of variances.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::VarianceMean()
+    {
+        return Variance() / Count();
+    }
+
+    /// <summary>
+    ///     Computes the standard deviation for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The standard deviation.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::StandardDeviation()
+    {
+        return sqrt(Variance());
+    }
+
+    /// <summary>
+    ///     Computes the mean of standard deviations for a given history.
+    /// </summary>
+    /// <returns>
+    ///     The mean of standard deviations.
+    /// </returns>
+    double HillClimbing::MeasuredHistory::StandardDeviationMean()
+    {
+        return (m_count == 0) ? 0.0 : (StandardDeviation() / sqrt(m_count * 1.0));
+    }
+
+    /// <summary>
+    ///     Tests if the difference between two measurement histories is statistically significant to
+    ///     make a hill climbing decision.
+    /// </summary>
+    /// <remarks>
+    ///     A two sided test is used.
+    /// </remarks>
+    /// <param name="value">
+    ///     The value representing the second history.
+    /// </param>
+    /// <param name="significanceLevel">
+    ///     The significance level in percent. Accepts 1 through 10.
+    /// </param>
+    /// <param name="totalSampleCount">
+    ///     The value representing the total number of samples for this history, including invalid samples and samples for previous settings.
+    /// </param>
+    /// <returns>
+    ///     -1 - second history is larger than this history
+    ///      0 - statistically identical
+    ///      1 - this history is larger than second history
+    /// </returns>
+    int HillClimbing::MeasuredHistory::SignificanceTest(double value, const int significanceLevel, unsigned int totalSampleCount)
+    {
+        MeasuredHistory singleValue;
+        singleValue.Add(value, totalSampleCount);
+
+        return MeasuredHistory::SignificanceTest(&singleValue, significanceLevel);
+    }
+
+    /// <summary>
+    ///     Tests if the difference between two measurement histories is statistically significant to
+    ///     make a hill climbing decision.
+    /// </summary>
+    /// <remarks>
+    ///     A two sided test is used.
+    /// </remarks>
+    /// <param name="pMeasuredHistory">
+    ///     The pointer to second measurement history.
+    /// </param>
+    /// <param name="significanceLevel">
+    ///     The significance level in percent. Accepts 1 through 10.
+    /// </param>
+    /// <returns>
+    ///     -1 - second history is larger than this history
+    ///      0 - statistically identical
+    ///      1 - this history is larger than second history
+    /// </returns>
+    int HillClimbing::MeasuredHistory::SignificanceTest(MeasuredHistory * pMeasuredHistory, const int significanceLevel)
+    {
+        const int critSize = 10;
+        double critArray[critSize] = { 2.576, 2.3263, 2.17, 2.05, 1.96, 1.88, 1.81, 1.75, 1.70, 1.64 };
+
+        double thisVariance = this->VarianceMean();
+        double thisMean = Mean();
+        double secondVariance = pMeasuredHistory->VarianceMean();
+        double secondMean = pMeasuredHistory->Mean();
+
+        _CONCRT_ASSERT(significanceLevel > 0 && significanceLevel <= 10); // Invalid significance level
+
+        int result = (int) sign(thisMean - secondMean);
+
+        if (thisVariance > 0 && secondVariance > 0)
+        {
+            double pooledVar = thisVariance / Count() + secondVariance / pMeasuredHistory->Count();
+
+            double testStatistic = (thisMean - secondMean) / sqrt(pooledVar);
+            double critVal = critArray[significanceLevel-1];
+            double absVal = abs(testStatistic);
+
+            if (absVal < critVal)
+            {
+                result = 0;
+            }
+        }
+
+        return result;
+    }
+
+#if defined(CONCRT_TRACING)
+
+    // Logging mechanism
+
+    struct HillClimbingLogEntry
+    {
+        long sampleCount;
+        unsigned int currentTotalSampleCount;
+        double throughput;
+        double currentHistoryMean;
+        double currentHistoryStd;
+        double lastHistoryMean;
+        double lastHistoryStd;
+        unsigned int currentControlSetting;
+        unsigned int lastControlSetting;
+        unsigned int currentHistoryCount;
+        unsigned int lastHistoryCount;
+        HillClimbingStateTransition transition;
+    };
+
+    static const int HillClimbingLogCapacity = 100;
+    static HillClimbingLogEntry HillClimbingLog[HillClimbingLogCapacity];
+    static int HillClimbingLogFirstIndex = 0;
+    static int HillClimbingLogSize = 0;
+
+    static const wchar_t * const HillClimbingTransitionNames[] =
+    {
+        L"Warmup",
+        L"ContinueInitializing",
+        L"CompletedInitialization",
+        L"DoClimbing",
+        L"ChangePoint",
+        L"ContinueLookingForClimb",
+        L"Undefined"
+    };
+
+    /// <summary>
+    ///     Logs the hill climbing decision.
+    /// </summary>
+    /// <param name="recommendedSetting">
+    ///     The control setting to be established.
+    /// </param>
+    /// <param name="transition">
+    ///     The transition that is recommended by hill climbing.
+    /// </param>
+    /// <param name="numberOfSamples">
+    ///     The number of sample points in this measurement, including invalid ones.
+    /// </param>
+    /// <param name="completionRate">
+    ///     The number of completed units or work in that period of time.
+    /// </param>
+    /// <param name="arrivalRate">
+    ///     The number of incoming units or work in that period of time.
+    /// </param>
+    /// <param name="queueLength">
+    ///     The total length of the work queue.
+    /// </param>
+    /// <param name="throughput">
+    ///     The throughput of the given instance.
+    /// </param>
+    void HillClimbing::LogData(unsigned int recommendedSetting, HillClimbingStateTransition transition, unsigned int numberOfSamples,
+        unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength, double throughput)
+    {
+        //
+        // First, log to memory so we can see it in the debugger
+        //
+        int index = (HillClimbingLogFirstIndex + HillClimbingLogSize) % HillClimbingLogCapacity;
+        if (HillClimbingLogSize == HillClimbingLogCapacity)
+        {
+            HillClimbingLogFirstIndex = (HillClimbingLogFirstIndex + 1) % HillClimbingLogCapacity;
+            HillClimbingLogSize--; //hide this slot while we update it
+        }
+
+        HillClimbingLogEntry * entry = &HillClimbingLog[index];
+        unsigned int minimumSetting = m_pSchedulerProxy->MinHWThreads();
+        unsigned int maximumSetting = m_pSchedulerProxy->DesiredHWThreads();
+
+        entry->sampleCount = m_sampleCount;
+        entry->currentTotalSampleCount = numberOfSamples;
+        entry->throughput = throughput;
+        entry->transition = transition;
+        entry->currentControlSetting = m_currentControlSetting;
+        entry->lastControlSetting = m_lastControlSetting;
+
+        MeasuredHistory * currentHistory = GetHistory(m_currentControlSetting);
+        entry->currentHistoryCount = currentHistory->Count();
+        entry->currentHistoryMean = currentHistory->Mean();
+        entry->currentHistoryStd = currentHistory->StandardDeviation();
+
+        MeasuredHistory * lastHistory = GetHistory(m_lastControlSetting);
+        entry->lastHistoryCount = lastHistory->Count();
+        entry->lastHistoryMean = lastHistory->Mean();
+        entry->lastHistoryStd = lastHistory->StandardDeviation();
+
+        HillClimbingLogSize++;
+
+        const int bufferSize = 180;
+        const wchar_t * delim = L"*******************************************************";
+
+        wchar_t dateBuffer[bufferSize];
+        SYSTEMTIME time;
+        GetLocalTime(&time);
+        int dateLen = GetDateFormatEx(LOCALE_NAME_USER_DEFAULT, DATE_SHORTDATE, &time, NULL, dateBuffer, bufferSize);
+        dateBuffer[dateLen-1] = L' ';
+        GetTimeFormatEx(LOCALE_NAME_USER_DEFAULT, TIME_FORCE24HOURFORMAT | TIME_NOTIMEMARKER, &time, NULL, dateBuffer + dateLen, bufferSize - dateLen);
+
+        TRACE(CONCRT_TRACE_HILLCLIMBING, L"%ls\n Process: %u\n Scheduler: %d\n Date: %ls\n Number of samples: %d\n Number of samples in this measurement (including invalid): %d\n Completions: %d\n Arrivals: %d\n Queue length: %d\n Throughput: %.4f\n Transition: %ls\n Next random move: %ls\n Minimum: %d\n Maximum: %d\n Current setting: %d\n  * count: %d mean: %g dev: %g varm: %g\n Last setting: %d\n  * count: %d mean: %g dev: %g varm: %g\n -----\n Recommended setting: %d\n%ls\n",
+            delim,
+            GetCurrentProcessId(),
+            m_id,
+            dateBuffer,
+            m_sampleCount,
+            numberOfSamples,
+            completionRate,
+            arrivalRate,
+            queueLength,
+            throughput,
+            HillClimbingTransitionNames[transition],
+            m_nextRandomMoveIsUp ? L"Up" : L"Down",
+            minimumSetting,
+            maximumSetting,
+            m_currentControlSetting,
+            currentHistory->Count(),
+            currentHistory->Mean(),
+            currentHistory->StandardDeviation(),
+            currentHistory->CoefficientOfVariationMean(),
+            m_lastControlSetting,
+            lastHistory->Count(),
+            lastHistory->Mean(),
+            lastHistory->StandardDeviation(),
+            lastHistory->CoefficientOfVariationMean(),
+            recommendedSetting,
+            delim);
+    }
+#endif
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/HillClimbing.h

@@ -0,0 +1,410 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// HillClimbing.h
+//
+// Defines classes for the HillClimbing concurrency-optimization algorithm.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+
+    /// <summary>
+    ///     An enum representing all possible hill climbing transition moves.
+    /// </summary>
+    enum HillClimbingStateTransition
+    {
+        Warmup,
+        ContinueInitializing,
+        CompletedInitialization,
+        DoClimbing,
+        ChangePoint,
+        ContinueLookingForClimb,
+        Undefined,
+    };
+
+    /// <summary>
+    ///     A class responsible for hill climbing.
+    /// </summary>
+    class HillClimbing
+    {
+    public:
+
+        /// <summary>
+        ///     Creates a new instance of hill climbing.
+        /// </summary>
+        /// <param name="id">
+        ///     Scheduler id.
+        /// </param>
+        /// <param name="numberOfCores">
+        ///     Number that represents the maximum resources available on the machine.
+        /// </param>
+        /// <param name="pSchedulerProxy">
+        ///     The scheduler proxy that controls this hill climbing instance.
+        /// </param>
+        HillClimbing(unsigned int id, unsigned int numberOfCores, SchedulerProxy * pSchedulerProxy);
+
+        /// <summary>
+        ///     External call passing statistical information to hill climbing. Based on these
+        ///     statistics, hill climbing will give a recommendation on the number of resources to be used.
+        /// </summary>
+        /// <param name="currentControlSetting">
+        ///     The control setting used in this period of time.
+        /// </param>
+        /// <param name="completionRate">
+        ///     The number of completed units or work in that period of time.
+        /// </param>
+        /// <param name="arrivalRate">
+        ///     The number of incoming units or work in that period of time.
+        /// </param>
+        /// <param name="queueLength">
+        ///     The total length of the work queue.
+        /// </param>
+        /// <returns>
+        ///     The recommended number of resources to be used.
+        /// </returns>
+        unsigned int Update(unsigned int currentControlSetting, unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength);
+
+    private:
+
+        /// <summary>
+        ///     A class responsible for keeping hill climbing history measurements.
+        /// </summary>
+        class MeasuredHistory
+        {
+        public:
+
+            /// <summary>
+            ///     Creates a new measurement history.
+            /// </summary>
+            MeasuredHistory();
+
+            /// <summary>
+            ///     Adds a new history data point.
+            /// </summary>
+            /// <param name="dataValue">
+            ///     The value representing throughput in this invocation.
+            /// </param>
+            /// <param name="totalSampleCount">
+            ///     The value representing the total number of samples for this history, including invalid samples and samples for previous settings.
+            /// </param>
+            void Add(const double data, unsigned int totalSampleCount);
+
+            /// <summary>
+            ///     Clears the history values for this control setting.
+            /// </summary>
+            /// <param name="controlSetting">
+            ///     The control setting to reset.
+            /// </param>
+            void Clear(unsigned int controlSetting);
+
+            /// <summary>
+            ///     Gets the count for this history measurement.
+            /// </summary>
+            /// <returns>
+            ///     The count.
+            /// </returns>
+            int Count();
+
+            /// <summary>
+            ///     Gets the count at the last data point for this history measurement.
+            /// </summary>
+            /// <returns>
+            ///     The last data point count.
+            /// </returns>
+            unsigned int LastDataPointCount();
+
+            /// <summary>
+            ///     Gets the control setting for this history measurement.
+            /// </summary>
+            /// <returns>
+            ///     The control setting.
+            /// </returns>
+            int ControlSetting();
+
+            /// <summary>
+            ///     Computes the mean for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The mean.
+            /// </returns>
+            double Mean();
+
+            /// <summary>
+            ///     Computes the coefficient of variation for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The coefficient of variation.
+            /// </returns>
+            double CoefficientOfVariation();
+
+            /// <summary>
+            ///     Computes the mean of coefficients of variation for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The mean of coefficients of variation.
+            /// </returns>
+            double CoefficientOfVariationMean();
+
+            /// <summary>
+            ///     Computes the variance for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The variance.
+            /// </returns>
+            double Variance();
+
+            /// <summary>
+            ///     Computes the mean of variances for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The mean of variances.
+            /// </returns>
+            double VarianceMean();
+
+            /// <summary>
+            ///     Computes the standard deviation for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The standard deviation.
+            /// </returns>
+            double StandardDeviation();
+
+            /// <summary>
+            ///     Computes the mean of standard deviations for a given history.
+            /// </summary>
+            /// <returns>
+            ///     The mean of standard deviations.
+            /// </returns>
+            double StandardDeviationMean();
+
+            /// <summary>
+            ///     Tests if the difference between two measurement histories is statistically significant to
+            ///     make a hill climbing decision.
+            /// </summary>
+            /// <remarks>
+            ///     A two sided test is used.
+            /// </remarks>
+            /// <param name="value">
+            ///     The value representing the second history.
+            /// </param>
+            /// <param name="significanceLevel">
+            ///     The significance level in percent. Accepts 1 through 10.
+            /// </param>
+            /// <param name="totalSampleCount">
+            ///     The value representing the total number of samples for this history, including invalid samples and samples for previous settings.
+            /// </param>
+            /// <returns>
+            ///     -1 - second history is larger than this history
+            ///      0 - statistically identical
+            ///      1 - this history is larger than second history
+            /// </returns>
+            int SignificanceTest(double value, const int significanceLevel, unsigned int totalSampleCount);
+
+            /// <summary>
+            ///     Tests if the difference between two measurement histories is statistically significant to
+            ///     make a hill climbing decision.
+            /// </summary>
+            /// <remarks>
+            ///     A two sided test is used.
+            /// </remarks>
+            /// <param name="pMeasuredHistory">
+            ///     The pointer to second measurement history.
+            /// </param>
+            /// <param name="significanceLevel">
+            ///     The significance level in percent. Accepts 1 through 10.
+            /// </param>
+            /// <returns>
+            ///     -1 - second history is larger than this history
+            ///      0 - statistically identical
+            ///      1 - this history is larger than second history
+            /// </returns>
+            int SignificanceTest(MeasuredHistory * pMeasuredHistory, const int significanceLevel);
+
+        private:
+
+            // Running sum of throughputs
+            double m_sum;
+
+            // Sum of throughput squares
+            double m_sumOfSquares;
+
+            // Count of measurements in this history
+            int m_count;
+
+            // An integer representing the control setting for this history measurement
+            int m_controlSetting;
+
+            // Last count value when a measurement was taken (used for relevance test)
+            unsigned int m_lastDataPointCount;
+        };
+
+        /// <summary>
+        ///     Makes a pseudo-random hill climbing move by alternating between up and down.
+        /// </summary>
+        /// <returns>
+        ///     The random move.
+        /// </returns>
+        int GetRandomMove();
+
+        /// <summary>
+        ///     Recommends NewControlSetting to be used.
+        /// </summary>
+        /// <param name="newControlSetting">
+        ///     The control setting to be established.
+        /// </param>
+        /// <returns>
+        ///     New control setting to be used.
+        /// </returns>
+        unsigned  RecommendControlSetting(unsigned int newControlSetting);
+
+        /// <summary>
+        ///     Establishes control setting as current. This is the only method that updates the control settings.
+        /// </summary>
+        /// <param name="newControlSetting">
+        ///     The control setting to be established.
+        /// </param>
+        void EstablishControlSetting(unsigned int newControlSetting);
+
+        /// <summary>
+        ///     Determines whether a given history measurement is stable enough to make a hill climbing move.
+        /// </summary>
+        /// <returns>
+        ///     True if history measurement is stable.
+        /// </returns>
+        bool IsStableHistory(MeasuredHistory * pMeasuredHistory);
+
+        /// <summary>
+        ///     Calculates the throughput based on the input parameters.
+        /// </summary>
+        /// <param name="numberOfSamples">
+        ///     The number of sample points in this measurement, including invalid ones.
+        /// </param>
+        /// <param name="completionRate">
+        ///     The number of completed units or work in that period of time.
+        /// </param>
+        /// <param name="arrivalRate">
+        ///     The number of incoming units or work in that period of time.
+        /// </param>
+        /// <param name="queueLength">
+        ///     The total length of the work queue.
+        /// </param>
+        /// <returns>
+        ///     The calculated throughput.
+        /// </returns>
+        double CalculateThroughput(unsigned int numberOfSamples, unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength);
+
+        /// <summary>
+        ///     Calculates the throughput gradient given two history measurements.
+        /// </summary>
+        /// <param name="fromSetting">
+        ///     The control setting to move from.
+        /// </param>
+        /// <param name="toSetting">
+        ///     The control setting to move to.
+        /// </param>
+        /// <returns>
+        ///     A value representing a gradient between two measurements.
+        /// </returns>
+        double CalculateThroughputGradient(int fromSetting, int toSetting);
+
+        /// <summary>
+        ///     Flushes all measurement histories that are no longer relevant.
+        /// </summary>
+        void FlushHistories();
+
+        /// <summary>
+        ///     Clears all measurement histories.
+        /// </summary>
+        void ClearHistories();
+
+        /// <summary>
+        ///     Gets the history measurement for a given control setting.
+        /// </summary>
+        /// <returns>
+        ///     The history measurement.
+        /// </returns>
+        MeasuredHistory * GetHistory(unsigned int controlSetting);
+
+        // The maximum number of histories to keep
+        static const unsigned int MaxHistoryCount = 64;
+
+        // The array where history data is kept
+        MeasuredHistory m_histories[MaxHistoryCount];
+
+        // Scheduler proxy to which this hill climbing instance belongs
+        SchedulerProxy * m_pSchedulerProxy;
+
+        // Used to determine the magnitude of moves, in units of (coefficient of variation)/(thread count)
+        double m_controlGain;
+
+        // Maximum number of resources that can be changed in one transition
+        unsigned int m_maxControlSettingChange;
+
+        // The current amount of resources allocated in this hill climbing instance
+        unsigned int m_currentControlSetting;
+
+        // The amount of resources allocated in this hill climbing instance before the last move
+        unsigned int m_lastControlSetting;
+
+        // Scheduler id
+        unsigned int m_id;
+
+        // Number of samples collected
+        unsigned long m_sampleCount;
+
+        // Number of samples collected including invalid samples, across settings
+        unsigned long m_totalSampleCount;
+
+        // Number of consecutive invalid samples
+        unsigned long m_invalidCount;
+
+        // Save sum of completions for consecutive invalid samples
+        unsigned int m_saveCompleted;
+
+        // Save sum of arrivals for consecutive invalid samples
+        unsigned int m_saveIncoming;
+
+        // Determines where the next random move is going
+        bool m_nextRandomMoveIsUp;
+
+#if defined(CONCRT_TRACING)
+        /// <summary>
+        ///     Logs the hill climbing decision by constructing a CSV dump of data.
+        /// </summary>
+        /// <param name="recommendedSetting">
+        ///     The control setting to be established.
+        /// </param>
+        /// <param name="transition">
+        ///     The transition that is recommended by hill climbing.
+        /// </param>
+        /// <param name="numberOfSamples">
+        ///     The number of sample points in this measurement, including invalid ones.
+        /// </param>
+        /// <param name="completionRate">
+        ///     The number of completed units or work in that period of time.
+        /// </param>
+        /// <param name="arrivalRate">
+        ///     The number of incoming units or work in that period of time.
+        /// </param>
+        /// <param name="queueLength">
+        ///     The total length of the work queue.
+        /// </param>
+        /// <param name="throughput">
+        ///     The throughput of the given instance.
+        /// </param>
+        void LogData(unsigned int recommendedSetting, HillClimbingStateTransition transition, unsigned int numberOfSamples,
+            unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength, double throughput);
+#endif
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/InternalContextBase.h

@@ -0,0 +1,627 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// InternalContextBase.h
+//
+// Header file containing the base class definition for an internal execution context.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+
+    /// <summary>
+    ///     Implements the base class for ConcRT internal contexts.
+    /// </summary>
+
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class InternalContextBase : public IExecutionContext, public ContextBase
+    {
+    public:
+
+        using ContextBase::GetId;
+
+        //
+        // Public methods
+        //
+
+        /// <summary>
+        ///     Constructs the base class object for an internal context.
+        /// </summary>
+        InternalContextBase(SchedulerBase *pScheduler);
+
+        /// <summary>
+        ///     Causes the internal context to block yielding the virtual processor to a different internal context.
+        /// </summary>
+        virtual void Block();
+
+        /// <summary>
+        ///     Unblocks the internal context putting it on a runnables collection in its schedule group.
+        /// </summary>
+        virtual void Unblock();
+
+        /// <summary>
+        ///     Determines whether or not the context is synchronously blocked at this given time.
+        /// </summary>
+        /// <returns>
+        ///     Whether context is in synchronous block state.
+        /// </returns>
+        virtual bool IsSynchronouslyBlocked() const
+        {
+            return (m_contextSwitchingFence == 2);
+        }
+
+        /// <summary>
+        ///     Yields the virtual processor to a different runnable internal context if one is found.
+        /// </summary>
+        virtual void Yield();
+
+        /// <summary>
+        ///     Yields the virtual processor to a different runnable internal context if one is found.
+        ///
+        ///     This is intended for spin loops.
+        /// </summary>
+        virtual void SpinYield();
+
+        /// <summary>
+        ///     See comments for Concurrency::Context::Oversubscribe.
+        /// </summary>
+        virtual void Oversubscribe(bool beginOversubscription);
+
+        /// <summary>
+        ///     Destroys the base class object for an internal context.
+        /// </summary>
+        virtual ~InternalContextBase();
+
+        /// <summary>
+        ///     Returns an identifier to the virtual processor the context is currently executing on, if any.
+        /// </summary>
+        virtual unsigned int GetVirtualProcessorId() const;
+
+        /// <summary>
+        ///     Toggle the flag that ensures that scheduler is not deleted until adding is completely finished.
+        /// </summary>
+        /// <param name="value">
+        ///     The value to set the flag to.
+        /// </param>
+        void CrossGroupRunnable(LONG value) { m_fCrossGroupRunnable = value; }
+
+        /// <summary>
+        ///     Set the value of the oversubscribed virtual processor for a context that invokes Oversubscribe.
+        /// </summary>
+        void SetOversubscribedVProc(VirtualProcessor * pVirtualProcessor) { m_pOversubscribedVProc = pVirtualProcessor; }
+
+        /// <summary>
+        ///     Called to retrieve the oversubscribed vproc and reset it to null.
+        /// </summary>
+        VirtualProcessor * GetAndResetOversubscribedVProc(VirtualProcessor * pExpectedVirtualProcessor);
+
+        /// <summary>
+        ///     Returns a scheduler unique identifier for the context.
+        /// </summary>
+        /// <returns>
+        ///     The Id of the context.
+        /// </returns>
+        virtual unsigned int GetId() const;
+
+        /// <summary>
+        ///     Returns the scheduler to which this context belongs.
+        /// </summary>
+        /// <returns>
+        ///     The owning scheduler.
+        /// </returns>
+        virtual IScheduler * GetScheduler();
+
+        /// <summary>
+        ///     Returns the thread proxy which is executing this context.  Until the Dispatch method has been called on the given
+        ///     context, this will return NULL.  Once the Dispatch method has been called, this returns the IThreadProxy which
+        ///     was passed into the Dispatch method.
+        /// </summary>
+        /// <returns>
+        ///     The thread proxy which dispatched this particular context, otherwise NULL.
+        /// </returns>
+        virtual IThreadProxy * GetProxy();
+
+#if _DEBUG
+        // _DEBUG helper
+        DWORD GetThreadId() const;
+#endif
+
+        /// <summary>
+        ///     Sets the thread proxy which is executing this context.  The caller must save this and return it upon a call to the GetProxy method.
+        ///     Note that the resource manager guarantees stability of the thread proxy while inside the Dispatch method.
+        /// </summary>
+        /// <param name="pThreadProxy">
+        ///     The thread proxy which dispatched this particular context.
+        /// </param>
+        /// <returns>
+        ///     An indication of success.
+        /// </returns>
+        virtual void SetProxy(IThreadProxy *pThreadProxy);
+
+        /// <summary>
+        ///     The method that is called when a thread proxy starts executing a particular context.  The thread proxy which executes
+        ///     the context is passed into this method and must be saved and returned on a call to the get_Proxy method.
+        /// </summary>
+        /// <param name="pDispatchState">
+        ///     The state under which this IExecutionContext is being dispatched.
+        /// </param>
+        virtual void Dispatch(DispatchState * pDispatchState);
+
+        /// <summary>
+        ///     Allocates a block of memory of the size specified.
+        /// </summary>
+        /// <param name="numBytes">
+        ///     Number of bytes to allocate.
+        /// </param>
+        /// <returns>
+        ///     A pointer to newly allocated memory.
+        /// </returns>
+        virtual void* Alloc(size_t numBytes);
+
+        /// <summary>
+        ///     Frees a block of memory previously allocated by the Alloc API.
+        /// </summary>
+        /// <param name="pAllocation">
+        ///     A pointer to an allocation previously allocated by Alloc.
+        /// </param>
+        virtual void Free(void* pAllocation);
+
+        /// <summary>
+        ///     Swaps the existing schedule group with the one supplied. This function should be called when the context already
+        ///     has a schedule group. It decrements the existing group reference count, and references the new one if the caller
+        ///     indicates so.
+        /// </summary>
+        /// <param name="pNewSegment">
+        ///     The new group to assign to the context. This may be NULL.
+        /// </param>
+        /// <param name="referenceNewGroup">
+        ///     Whether the context should reference the new group. In some cases there may be an existing reference
+        ///     transferred to the context, in which case this parameter is false.
+        /// </param>
+        void SwapScheduleGroupSegment(ScheduleGroupSegmentBase* pNewSegment, bool referenceNewGroup = false);
+
+        /// <summary>
+        ///     Increments the count of work coming in.
+        /// </summary>
+        void IncrementEnqueuedTaskCounter()
+        {
+            m_pVirtualProcessor->m_enqueuedTaskCounter++;
+        }
+
+        void IncrementEnqueuedTaskCounterHelper();
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter()
+        {
+            m_pVirtualProcessor->m_dequeuedTaskCounter++;
+        }
+
+        /// <summary>
+        ///     Increments the count of work being done.
+        /// </summary>
+        void IncrementDequeuedTaskCounter(unsigned int count)
+        {
+            m_pVirtualProcessor->m_dequeuedTaskCounter += count;
+        }
+
+        void IncrementDequeuedTaskCounterHelper(unsigned int count);
+
+        /// <summary>
+        ///     In some cases internal context has not yet received a virtual processor so we have
+        ///     to save the fact that the work was dequeued and we'll update it in Affinitize.
+        /// </summary>
+        void SaveDequeuedTask()
+        {
+            ASSERT(!m_fHasDequeuedTask);
+            m_fHasDequeuedTask = true;
+        }
+
+        /// <summary>
+        ///     Notifies that some work was skipped by an iteration of dispatch loop of this context
+        /// </summary>
+        void NotifyWorkSkipped()
+        {
+            m_fWorkSkipped = true;
+        }
+
+#if defined(_DEBUG)
+        /// <summary>
+        ///     Gets the debug bits.
+        /// </summary>
+        DWORD GetDebugBits() const
+        {
+            return m_ctxDebugBits;
+        }
+
+        /// <summary>
+        ///     Sets a series of internal debugging bits for the context.
+        /// </summary>
+        /// <param name="bits">
+        ///     A bitmapped series of CTX_DEBUGBIT_* flags to set within the context.
+        /// </param>
+        void SetDebugBits(DWORD bits)
+        {
+            m_ctxDebugBits |= bits;
+        }
+
+        /// <summary>
+        ///     Clears a series of internal debugging bits for the context.
+        /// </summary>
+        /// <param name="bits">
+        ///     A bitmapped series of CTX_DEBUGBIT_* flags to clear within the context.
+        /// </param>
+        void ClearDebugBits(DWORD bits)
+        {
+            m_ctxDebugBits &= ~bits;
+        }
+
+        /// <summary>
+        ///     Completely clears all debug bits.
+        /// </summary>
+        void ClearDebugBits()
+        {
+            m_ctxDebugBits = 0;
+        }
+
+        void NotifyAcquired()
+        {
+            m_lastAcquiredTid = GetCurrentThreadId();
+        }
+#endif // _DEBUG
+
+        /// <summary>
+        ///     Returns whether the context is in the idle pool or not. Finalization will call this during the sweep phase to
+        //      determine all the blocked contexts. A context in the idle pool is considered "not blocked".
+        /// </summary>
+        bool IsIdle() const
+        {
+            return m_fIdle;
+        }
+
+        /// <summary>
+        ///     Prepare a context for execution by associating a scheduler group/chore with it. Scheduler
+        //      shall call this routine before executing an internal context
+        /// </summary>
+        void PrepareForUse(ScheduleGroupSegmentBase* pSegment, _Chore *pChore, bool choreStolen);
+
+        /// <summary>
+        ///     Returns whether the context is prepared for execution or must be initialized prior to use.  An unprepared context
+        ///     must be initialized via PrepareForUse().
+        /// </summary>
+        bool IsPrepared() const
+        {
+            return (m_pSegment != NULL);
+        }
+
+        /// <summary>
+        ///     Remove a context from execution by dis-associating it from any scheduler group/chore.
+        /// </summary>
+        void RemoveFromUse();
+
+    protected:
+
+        //
+        // Protected types
+        //
+
+        enum ReasonForSwitch
+        {
+            GoingIdle,
+            Blocking,
+            Yielding,
+            Nesting
+        };
+
+        //
+        // Protected data members
+        //
+
+        // The thread proxy that is executing this context's dispatch loop, if any.
+        IThreadProxy * volatile m_pThreadProxy; // 4/8
+
+        //
+        // Protected methods
+        //
+
+        /// <summary>
+        ///     Spins until the 'this' context is in a firmly blocked state
+        /// </summary>
+        void SpinUntilBlocked();
+
+        /// <summary>
+        ///     Adds the context to a runnables collection, either on the virtual processor, or the schedule group
+        /// </summary>
+        /// <param name="bias">
+        ///     A location specifying where to bias the awakening of virtual processors to.
+        /// </param>
+        virtual void AddToRunnables(location bias = location());
+
+        /// <summary>
+        ///     Switches from one internal context to another.
+        /// </summary>
+        void SwitchTo(InternalContextBase* pContext, ReasonForSwitch reason);
+
+        /// <summary>
+        ///     Switches out the internal context. Useful when the virtual processor is to be retired.
+        ///     Is also used when un-nesting a scheduler and the context is returning to its original scheduler.
+        /// </summary>
+        /// <param name="reason">
+        ///     The reason for switching out of this vproc
+        /// </param>
+        /// <returns>
+        ///     True if the context has been canceled.
+        /// </returns>
+        bool SwitchOut(ReasonForSwitch reason);
+
+        /// <summary>
+        ///     Cancels the context, causing it to exit the dispatch loop if it is executing on a virtual processor
+        /// </summary>
+        virtual void Cancel();
+
+        /// <summary>
+        ///     If internal context does not own this virtual processor then claim it back. This might require
+        ///     waiting until it becomes available.
+        /// </summary>
+        void ReclaimVirtualProcessor();
+
+        /// <summary>
+        ///     This function is called to execute the associated chore if one is available. The chore can be a stolen unrealized
+        ///     chore or realized chore.
+        /// </summary>
+        /// <returns>
+        ///     Returns true if an associated chore was executed, false otherwise.
+        /// </returns>
+        bool ExecutedAssociatedChore();
+
+        /// <summary>
+        ///     Performs the necessary cleanup for a canceled context in its dispatch routine.
+        /// <summary>
+        void CleanupDispatchedContextOnCancel();
+
+        /// <summary>
+        ///     Called in the dispatch loop to check if the virtual processor the context is running on is marked for retirement,
+        ///     and retires the virtual processor if it is.
+        /// <summary>
+        /// <returns>
+        ///     True if the virtual processor was retired, false otherwise.
+        /// </returns>
+        bool IsVirtualProcessorRetired();
+
+        /// <summary>
+        ///     Searches for work using the search algorithm specified by the scheduler's policy. Also prepares the context to execute
+        ///     work by reclaiming the virtual processor if necessary.
+        /// </summary>
+        /// <param name=pWork>
+        ///     A pointer to a work item which is filled in if work was found.
+        /// </param>
+        /// <returns>
+        ///     True if work was found, false otherwise.
+        /// </returns>
+        bool WorkWasFound(WorkItem * pWork);
+
+        /// <summary>
+        ///     Switches to the runnable context represented by the work item.
+        /// </summary>
+        /// <param name=pWork>
+        ///     A pointer to a work item to be executed.
+        /// </param>
+        void SwitchToRunnableContext(WorkItem * pWork);
+
+        /// <summary>
+        ///     Executes the chore (realized or unrealized) specified by the work item.
+        /// </summary>
+        /// <param name=pWork>
+        ///     A pointer to a work item that represents a realized or unrealized chore.
+        /// </param>
+        void ExecuteChoreInline(WorkItem * pWork);
+
+        /// <summary>
+        ///     This method implements the wait-for-work and cancellation protocol.
+        /// </summary>
+        void WaitForWork(void);
+
+        /// <summary>
+        ///     Performs cleanup of the internal thread context.
+        /// </summary>
+        void Cleanup();
+
+        /// <summary>
+        ///     Called before this executes on a given virtual processor.
+        /// </summary>
+        virtual void PrepareToRun(VirtualProcessor *pVProc)
+        {
+#if defined(_DEBUG)
+            m_lastRunPrepareTimeStamp = _ReadTimeStampCounter();
+            m_prepareCount++;
+            m_lastAffinitizedTid = GetCurrentThreadId();
+#endif // _DEBUG
+            m_pVirtualProcessor = pVProc;
+            CONCRT_COREASSERT(m_pSegment != NULL);
+            InterlockedExchange(&m_blockedState, CONTEXT_NOT_BLOCKED);
+        }
+
+        // Virtual processor the context is executing on.
+#if defined(_DEBUG)
+        void _PutVirtualProcessor(VirtualProcessor *pVirtualProcessor)
+        {
+            //
+            // If this assertion fires, someone is changing m_pVirtualProcessor outside a critical region.  Doing this violates safety
+            // on a UMS scheduler.  m_pVirtualProcessor is not guaranteed to be stable on a UMS context.  All manipulation must happen
+            // inside a critical region.
+            //
+            CONCRT_COREASSERT(_m_pVirtualProcessor == NULL || IsInsideCriticalRegion());
+            _m_pVirtualProcessor = pVirtualProcessor;
+        }
+
+        VirtualProcessor *_GetVirtualProcessor() const
+        {
+            //
+            // If this assertion fires, someone is examining m_pVirtualProcessor outside a critical region.  Doing this violates safety
+            // on a UMS scheduler.  m_pVirtualProcessor is not guaranteed to be stable on a UMS context.  All manipulation must happen
+            // inside a critical region.
+            //
+            CONCRT_COREASSERT(_m_pVirtualProcessor == NULL || IsInsideCriticalRegion());
+            return _m_pVirtualProcessor;
+        }
+
+        __declspec(property(get=_GetVirtualProcessor, put=_PutVirtualProcessor)) VirtualProcessor *m_pVirtualProcessor;
+        VirtualProcessor * volatile _m_pVirtualProcessor;
+
+        VirtualProcessor *UNSAFE_CurrentVirtualProcessor() const
+        {
+            return _m_pVirtualProcessor;
+        }
+
+        void UNSAFE_SetVirtualProcessor(VirtualProcessor *pVirtualProcessor)
+        {
+            _m_pVirtualProcessor = pVirtualProcessor;
+        }
+#else
+        VirtualProcessor * volatile m_pVirtualProcessor;
+
+        VirtualProcessor *UNSAFE_CurrentVirtualProcessor() const
+        {
+            return m_pVirtualProcessor;
+        }
+
+        void UNSAFE_SetVirtualProcessor(VirtualProcessor *pVirtualProcessor)
+        {
+            m_pVirtualProcessor = pVirtualProcessor;
+        }
+#endif
+
+    private:
+        friend class ExternalContextBase;
+        friend class SchedulerBase;
+        friend class ThreadScheduler;
+        friend class VirtualProcessor;
+        friend class SchedulingRing;
+        friend class location;
+        template <typename T> friend class Mailbox;
+        template <class T, class Counter> friend class Stack;
+        template <typename T> friend class SQueue;
+
+        // This helper is used to avoid circular reference:
+        // Mailbox -> InternalContextBase -> ContextBase -> WorkStealingQueue -> Mailbox
+        friend unsigned int GetProcessorMaskId(InternalContextBase * pContext);
+
+        //
+        // Private data
+        //
+
+        // Pointer to an oversubscribed virtual processor if one is present.
+        VirtualProcessor * volatile m_pOversubscribedVProc;
+
+        // Chore associated with the context - this could be a realized chore or a stolen chore. The chore is associated with the context
+        // either when the internal context first starts up, or it is picked out of the idle pool by the scheduler. The context must execute this chore
+        // before it starts looking for other work. This is used for indirect aliasing of unstructured task collections.
+        _Chore *m_pAssociatedChore;
+
+        // Counter that indicates how many times the internal context has spun waiting for work.
+        unsigned int m_searchCount;
+
+        // Flag that indicates whether the internal context is canceled.
+        volatile bool m_fCanceled;
+
+        // Flag that indicates whether the associated chore is a stolen unrealized chore or a realized chore.
+        bool m_fAssociatedChoreStolen{};
+
+        // Flag that indicates whether internal context is in the final search for work state.
+        bool m_fIsVisibleVirtualProcessor;
+
+        // Flag that indicates whether internal context has dequeued a piece of work without being able
+        // to immediately update the statistics numbers on a virtual processor (it was not affinitized).
+        bool m_fHasDequeuedTask : 1;
+
+        // Indicates that some work was skipped in the dispatch loop. Currently, this is set if we failed to check some of the work stealing
+        // queues due to in-progress task collection cancellation.
+        bool m_fWorkSkipped : 1;
+
+        // Debugging purposes: this informs whether the context was *EVER* put on a free list or whether it is a fresh context.
+        bool m_fEverRecycled : 1;
+
+        // Debug information (particularly useful for UMS)
+
+        //
+        // Time logging for forward progress determinations.
+        //
+        __int64 m_workStartTimeStamp{};
+        __int64 m_lastRunPrepareTimeStamp{};
+        DWORD m_prepareCount{};
+
+        DWORD m_ctxDebugBits{};
+
+        // The last TID this context was dispatched on.  You can normally get this from m_pThreadProxy.
+        DWORD m_lastDispatchedTid{};
+
+        // The last TID this context was acquired/created on.
+        DWORD m_lastAcquiredTid{};
+
+        // The last TID this context was affinitized on.
+        DWORD m_lastAffinitizedTid{};
+
+        //
+        // Tracks the last assigned thread proxy (normally the same as m_pThreadProxy) -- but may not be for recycled contexts.
+        //
+        IThreadProxy *m_pAssignedThreadProxy{};
+        IThreadProxy *m_pLastAssignedThreadProxy{};
+
+        // A flag that is used by contexts adding runnables to a scheduler. When those contexts (the ones performing the add)
+        // do not implicitly have a reference to the schedule group the runnable belongs to, setting this flag on the runnable
+        // context they are adding to the scheduler's queues, ensures that the group does not get destroyed and the scheduler
+        // does not get finalized while they are touching scheduler/schedule group data.
+        volatile LONG m_fCrossGroupRunnable;
+
+        // Intrusive next pointer for SafeSQueue.
+        InternalContextBase *m_pNext{};
+
+        // Flag that indicates whether the internal context is in the idle pool or not
+        volatile bool m_fIdle;
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Called to find work to switch to, when the current context needs to block or nest a different scheduler.
+        ///     The function may return NULL if no work was found and thread creation was disallowed by the thread
+        ///     throttler.
+        /// </summary>
+        InternalContextBase* FindWorkForBlockingOrNesting(bool& fSFWContext, bool& fBoundUnrealized);
+
+        /// <summary>
+        ///     Called when a context is nesting a scheduler. If nesting takes place on what is an internal context in
+        ///     the 'parent' scheduler, the context must return the virtual processor to the parent scheduler.
+        /// </summary>
+        void LeaveScheduler();
+
+        /// <summary>
+        ///     Called when a context is un-nesting a scheduler. If the parent context is an internal context, it needs
+        ///     to rejoin the parent scheduler by looking for a virtual processor it can execute on.
+        /// </summary>
+        void RejoinScheduler();
+
+        /// <summary>
+        ///     Called when the RM wakes up the thread for some reason.
+        /// </summary>
+        virtual void RMAwaken()
+        {
+        }
+
+    };
+
+    unsigned int GetProcessorMaskId(InternalContextBase* pContext);
+#pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Mailbox.h

@@ -0,0 +1,591 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Mailbox.h
+//
+// Class definition for task affine mailbox.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+#define SLOT_PENDING_EXPIRY 1
+#define FIELD_RESERVED 1
+
+namespace Concurrency
+{
+namespace details
+{
+    // This helper is used to avoid circular reference:
+    // Mailbox -> InternalContextBase -> ContextBase -> WorkStealingQueue -> Mailbox
+    unsigned int GetProcessorMaskId(InternalContextBase * pContext);
+
+    // *** NOTES ***
+    //
+    // Work stealing queues are associated with each context that the scheduler runs.  Each context is, by nature of what it has executed or been bound to,
+    // associated with a given schedule group segment and hence has a natural affinity.  This presents an interesting semantic with respect to work
+    // stealing tasks scheduled from that context.  Imagine:
+    //
+    // CONTEXT A (affinity locA)
+    //
+    //     tg.run(lambda1);
+    //     tg.run(lambda2, loc2);
+    //     tg.run(lambda3, loc3);
+    //     tg.run(lambda4, loc4);
+    //     tg.run(lambda5, loc5);
+    //     tg.wait();
+    //
+    // In this circumstance, lambda1 through lambda5 are pushed onto the work stealing queue associated with CONTEXT A.  Because context A has an associated
+    // affinity (locA -- which might not be a *specific* affinity -- it might be the system), all of these tasks have a natural affinity to locA.  When
+    // tasks lambda2 through lambda5 are scheduled, the caller has requested that, if stolen, those tasks run on locations other than the natural affinity
+    // of the work stealing queue.  In order to accommodate this in a work stealing scheduler, we mail lambda2 through lambda5 to a mailbox.
+    // The mailbox will be contained within a segment with affinity loc2, loc3, ..., loc5 within the schedule *GROUP* of CONTEXT A.
+    //
+    // This means that tasks lambda2 through lambda5 will be contained in two places in the scheduler simultaneously:
+    //
+    //     - On the work stealing queue for context A (which has natural affinity to locA)
+    //     - On a mailbox within the group of context A with affinity loc*
+    //
+    // In this case, the affinities are chained.  lambda2 has primary affinity to loc2 and secondary affinity to locA.  If a vproc within loc2 is available,
+    // it will go there; otherwise, if a vproc within locA is available, it will go there; otherwise, it will go anywhere subject to the rules of SFW.
+    //
+    // Having a given task in two places presents an interesting problem: task lifetime.  The ConcRT scheduler is not always in control of the lifetime of
+    // objects that are pushed onto the work stealing queue.  A lambda which is scheduled to a task_group has lifetime owned by the scheduler.  A task_handle
+    // which is scheduled to a (structured_)task_group has lifetime which is managed by the caller.
+    //
+    // Once a task is executed from *either* queue (the mailbox or the WSQ), the task can no longer safely be touched by the runtime.  In order to allow
+    // for this, affine tasks work as follows: the low bit of the chore pointer on the WSQ is utilized to indicate whether a task is an affine (mailed) task
+    // or not.  If the task is not affine, things work as they always have.  If the task *IS* affine, the WSQ keeps a side structure which holds a slot
+    // for the given WSQ chore.  The "slot" is Mailbox<T>::Slot.  The chore cannot be touched until ClaimSlot is called successfully.  The mailbox can do
+    // whatever is necessary under the covers to implement this interface.
+    //
+
+    //
+    // At present, there are some rather subtle lifetime rules about mailboxes and the objects which actually manage their storage.
+    //
+    // - A mailbox is bound to the lifetime of a schedule group segment.  Mailboxes have two sub-objects: slots and segments.  Both of these objects
+    //   can outlive the mailbox!
+    //
+    // - A mailbox slot is a handle to some location within a given mailbox.  The slot object is valid until Claim() is called on it.  After this method
+    //   returns, the slot is invalid.  Calling a method on it again will result in undefined behavior.
+    //
+    // - A mailbox segment is the backing storage for a portion of the mailbox queue.  Slots are chained and allocated in FIFO order to amortize the cost
+    //   of allocation.  Excepting the amortized allocation, a mailbox is lock-free (though not wait-free).  Mailbox segments have an implicit reference on them
+    //   for every slot within the segment.  The segment is freed once EVERY reference is removed.  Mailbox segments are only freed at safe points to give the
+    //   Dequeue code extra safety.  This implies that Dequeue operations on a mailbox must happen on an internal context within a critical region.
+    //
+
+    //
+    /// <summary>
+    ///     A lock-free fixed size FIFO of tasks associated with a particular object.  The mailbox is typically used
+    ///     for work stealing tasks affine to a particular location.
+    /// </summary>
+    template<typename T>
+    class Mailbox
+    {
+    private:
+
+        /// <summary>
+        ///     Represents a segment of a mailbox which contains a fixed number of slots.
+        /// </summary>
+        struct Segment
+        {
+            /// <summary>
+            ///     Constructs a new segment.
+            /// </summary>
+            Segment(SchedulerBase *pScheduler, const QuickBitSet &affinitySet, unsigned int size, unsigned int baseIdx) :
+                m_pScheduler(pScheduler), m_affinitySet(affinitySet), m_baseIdx(baseIdx), m_refs(0), m_pNext(NULL)
+            {
+                m_pQueue = _concrt_new T* volatile [size];
+                memset((void*)(m_pQueue), 0, sizeof(T* volatile) * size);
+            }
+
+            /// <summary>
+            ///     Destroys a segment.
+            /// </summary>
+            ~Segment()
+            {
+                delete[] m_pQueue;
+            }
+
+            bool AllSlotsClaimed(unsigned int count)
+            {
+                // Note that if this segment has already had its deletion refs set after all slots were claimed, this will
+                // return false. However, for the purpose we are using it for (deciding whether or not to set deletion refs),
+                // this is not a problem.
+                return (m_refs + count == 0);
+            }
+
+            /// <summary>
+            ///     Removes a reference from the segment.
+            /// </summary>
+            void Dereference()
+            {
+                if (static_cast<unsigned int>(InterlockedDecrement(reinterpret_cast<volatile long *>(&m_refs))) == 0)
+                    Expire();
+            }
+
+            /// <summary>
+            ///     Expires a segment.
+            /// </summary>
+            void Expire()
+            {
+                //
+                // This can be called during search-for-work as we touch a work stealing queue that has had a task mailed.  We do *NOT* want heap
+                // operations in search-for-work at ANY point.  As such, the deletion gets deferred to the scheduler's next safe point.
+                //
+                // This also guards against two Dequeuers (which are only on internal contexts during critical regions) from touching freed memory in
+                // locating their segment.  Enqueues are guarded with a different mechanism.
+                //
+                m_deletionSafePoint.InvokeAtNextSafePoint(reinterpret_cast<SafePointInvocation::InvocationFunction>(&Segment::StaticDelete),
+                                                          reinterpret_cast<void *>(this),
+                                                          m_pScheduler);
+            }
+
+            /// <summary>
+            ///      Marks how many dereferences must happen before the segment can delete itself.
+            /// </summary>
+            void SetDeletionReferences(unsigned int count)
+            {
+                if ((static_cast<unsigned int>(InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_refs), count)) + count) == 0)
+                    Expire();
+            }
+
+            /// <summary>
+            ///     Safe point routine to delete a segment.
+            /// </summary>
+            static void StaticDelete(Segment *pSegment)
+            {
+                delete pSegment;
+            }
+
+            // The scheduler to which the segment belongs.
+            SchedulerBase *m_pScheduler;
+
+            // The affinity of the segment.
+            QuickBitSet m_affinitySet;
+
+            // The queue of objects within the segment.
+            T* volatile * m_pQueue;
+
+            // The base index of the segment.
+            unsigned int m_baseIdx;
+
+            // The number of references remaining on the segment.
+            volatile unsigned int m_refs;
+
+            // The next segment within the mailbox.
+            Segment * m_pNext;
+
+            // The safe point at which the segment will be deleted.
+            SafePointInvocation m_deletionSafePoint;
+        };
+
+    public:
+
+        /// <summary>
+        ///     An opaque handle to a slot of a mailbox.  When an object is enqueued in the mailbox, a slot is returned.  If the item
+        ///     is placed on another list, the slot must be claimed before the object is utilized.
+        /// </summary>
+        class Slot
+        {
+        public:
+
+            Slot() : m_pSegment(NULL), m_relativeIdx(0)
+            {
+            }
+
+            Slot(const Slot& src) : m_pSegment(src.m_pSegment), m_relativeIdx(src.m_relativeIdx)
+            {
+            }
+
+            Slot& operator=(const Slot& rhs)
+            {
+                m_pSegment = rhs.m_pSegment;
+                m_relativeIdx = rhs.m_relativeIdx;
+
+                return *this;
+            }
+
+            bool IsEmpty() const
+            {
+                return m_pSegment == NULL;
+            }
+
+            /// <summary>
+            ///     Claims an object from a slot in an out-of-order and thread-safe manner.  If true is returned, this indicates that
+            ///     the caller has exclusive ownership of the object within that slot.
+            /// </summary>
+            bool Claim(T ** pClaimedObject = nullptr)
+            {
+                T* pObject = m_pSegment->m_pQueue[m_relativeIdx];
+                ASSERT(pObject != NULL);
+
+                if (pObject != reinterpret_cast<T*>(SLOT_PENDING_EXPIRY))
+                {
+                    T* pXchgObject = reinterpret_cast<T*>(
+                        InterlockedExchangePointer(reinterpret_cast<void * volatile *>(m_pSegment->m_pQueue + m_relativeIdx),
+                        reinterpret_cast<void *>(SLOT_PENDING_EXPIRY)));
+
+                    if (pXchgObject == pObject)
+                    {
+                        if (pClaimedObject)
+                            *pClaimedObject = pObject;
+                        return true;
+                    }
+
+                }
+
+                m_pSegment->Dereference();
+
+                return false;
+            }
+
+            bool DeferToAffineSearchers() const
+            {
+                InternalContextBase * pContext = static_cast<InternalContextBase *>(SchedulerBase::FastCurrentContext());
+                return (m_pSegment->m_pScheduler->HasSearchers(m_pSegment->m_affinitySet) &&
+                        !m_pSegment->m_affinitySet.IsSet(GetProcessorMaskId(pContext)));
+            }
+
+        private:
+
+            friend class Mailbox;
+
+            Slot(Segment *pSegment, unsigned int relativeIdx) : m_pSegment(pSegment), m_relativeIdx(relativeIdx)
+            {
+            }
+
+            Segment *m_pSegment;
+            unsigned int m_relativeIdx;
+
+        };
+
+        /// <summary>
+        ///     Constructs a new mailbox with the specified segment size.
+        /// </summary>
+        /// <param name="pScheduler">
+        ///     The scheduler to which this mailbox belongs.
+        /// </param>
+        /// <param name="fDeferAlloc">
+        ///     Indicates whether or not to defer allocation of the first segment until the first enqueue.
+        /// </param>
+        /// <param name="segmentSize">
+        ///     The size of the mailbox.  Note that the mailbox size is fixed once constructed.
+        /// </param>
+
+        Mailbox(SchedulerBase *pScheduler, const QuickBitSet&, bool fDeferAlloc = false, unsigned int segmentSize = s_segmentSize)
+            : m_pScheduler(pScheduler)
+            , m_segmentSize(segmentSize)
+            , m_pTailSegment(NULL)
+            , m_pHeadSegment(NULL)
+            , m_head(0)
+            , m_tail(0)
+        {
+            ASSERT((segmentSize & (segmentSize - 1)) == 0);
+
+            Initialize(m_affinitySet);
+
+            if (!fDeferAlloc)
+            {
+                m_pTailSegment = _concrt_new Segment(m_pScheduler, m_affinitySet, segmentSize, 0);
+                m_pHeadSegment = m_pTailSegment;
+            }
+        }
+
+        /// <summary>
+        ///     Destroys a mailbox.
+        /// </summary>
+        ~Mailbox()
+        {
+            Segment *pSegment = m_pHeadSegment;
+            while (pSegment != NULL)
+            {
+                Segment *pNextSegment = pSegment->m_pNext;
+
+                if (pSegment != m_pTailSegment)
+                    pSegment->SetDeletionReferences(m_segmentSize);
+                else
+                {
+                    //
+                    // How many items are in this segment?  That is how many must dereference the segment in order for its memory to be freed.
+                    // Set this number.  Note that this should *ONLY* be for the tail segment.
+                    //
+                    unsigned int numElements = m_tail - pSegment->m_baseIdx;
+                    ASSERT(numElements <= m_segmentSize);
+
+                    pSegment->SetDeletionReferences(numElements);
+                }
+
+                pSegment = pNextSegment;
+            }
+
+        }
+
+        /// <summary>
+        ///     Initializes key fields of the mailbox.
+        /// </summary>
+        void Initialize(const QuickBitSet& bitSet)
+        {
+            m_affinitySet = bitSet;
+            if (m_pHeadSegment)
+                m_pHeadSegment->m_affinitySet = bitSet;
+        }
+
+        /// <summary>
+        ///     Enqueues an object onto the mailbox and returns a pointer to the slot if the enqueue is successful.  Note that
+        ///     the Slot object may only be used in methods on the mailbox.
+        /// </summary>
+        /// <param name="pObject">
+        ///     The object to enqueue.
+        /// </param>
+        Slot Enqueue(T* pObject)
+        {
+            //
+            // Complete the pushes in order to avoid LocateMailboxSegment touching an invalid segment when an enqueue crosses a boundary in conjunction
+            // with a dequeue/claim -> free.
+            //
+            m_enqueueLock._Acquire();
+
+            Segment *pSegment = LocateMailboxSegment(m_tail, true);
+
+            unsigned int relativeIdx = m_tail - pSegment->m_baseIdx;
+            pSegment->m_pQueue[relativeIdx] = pObject;
+
+            // The Dequeue function will calculate the number of available messages based on m_tail.
+            // This memory fence will flush new m_tail to Dequeue. Be attention that there is no fence in the last lock release function.
+            // If the write to m_tail is observed by the Dequeue, all write operations before this point must be observed by Dequeue as well.
+            _InterlockedIncrement(reinterpret_cast<volatile long *>(&m_tail));
+
+            m_enqueueLock._Release();
+            return Slot(pSegment, relativeIdx);
+        }
+
+        /// <summary>
+        ///     Dequeues an object from the mailbox.
+        /// </summary>
+        /// <param name="pDequeuedElement">
+        ///     If the dequeue is successful, the dequeued element will be placed here.
+        /// </param>
+        ///
+        bool Dequeue(T **pDequeuedElement)
+        {
+            //
+            // Keep dequeueing until we either get something or the queue is empty.  We may dequeue a slot pending expiry.
+            //
+            for(;;)
+            {
+                unsigned int head = m_head;
+                for (;;)
+                {
+                    if (head == m_tail)
+                        return false;
+
+                    unsigned int xchgHead = static_cast<unsigned int> (
+                        InterlockedCompareExchange(reinterpret_cast<volatile long *>(&m_head), head + 1, head)
+                        );
+
+                    if (xchgHead == head)
+                        break;
+
+                    head = xchgHead;
+                }
+
+                Segment *pSegment = LocateMailboxSegment(head, false);
+
+                //
+                // Check if we need to update the head pointers if we have gone past the head segment. We will only remove segments from the queue if
+                // all their slots have been claimed. This is so that we do not inadvertently remove a segment a different thread in this routine
+                // is trying to to locate. Segments can only be located if they are between head and tail. The update must handle multiple dequeues
+                // happening simultaneously and trying to update this simultaneously!
+                //
+                // There is no ABA here because segments are freed at a safe point and the calling thread is always an internal context which participates
+                // in this mechanism.
+                //
+                if (pSegment != m_pHeadSegment)
+                {
+                    // Since the head is not moved until all slots are claimed, this segment's base index cannot be less than that of the head segment.
+                    // i.e. this segment must still be in the set [head, tail].
+                    CONCRT_COREASSERT(pSegment->m_baseIdx >= m_pHeadSegment->m_baseIdx);
+
+                    Segment *pHeadSegment = m_pHeadSegment;
+                    Segment *pReadSegment = pHeadSegment;
+
+                    // Travel forward from the head as long as we continue to find segments that have had all slots claimed.
+                    for(;;)
+                    {
+                        while (pReadSegment->AllSlotsClaimed(m_segmentSize))
+                        {
+                            pReadSegment = pReadSegment->m_pNext;
+                        }
+
+                        // If we've found a chain of segments (or a single segment) that has all slots claimed, try to change the head
+                        if (pReadSegment->m_baseIdx > pHeadSegment->m_baseIdx)
+                        {
+                            Segment *pXchgSegment = reinterpret_cast<Segment *>(
+                                InterlockedCompareExchangePointer(reinterpret_cast<void * volatile *>(&m_pHeadSegment),
+                                                                  reinterpret_cast<void *>(pReadSegment),
+                                                                  reinterpret_cast<void *>(pHeadSegment))
+                                );
+
+                            if (pXchgSegment == pHeadSegment)
+                            {
+                                //
+                                // The person who removes a segment (or a series of segments) from the list via the head is responsible for
+                                // setting their deletion references so that they properly delete!  The segments in the sublist described by
+                                // the half open range [pXchgSegment, pSegment) must be set.
+                                //
+                                Segment *pDelRef = pXchgSegment;
+                                while (pDelRef != pReadSegment)
+                                {
+                                    pDelRef->SetDeletionReferences(m_segmentSize);
+                                    pDelRef = pDelRef->m_pNext;
+                                }
+                                break;
+                            }
+
+                            pHeadSegment = pReadSegment = pXchgSegment;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+
+                    CONCRT_COREASSERT(m_pHeadSegment != NULL);
+                    CONCRT_COREASSERT(pSegment->m_baseIdx >= m_pHeadSegment->m_baseIdx);
+                }
+
+                unsigned int relativeIdx = head - pSegment->m_baseIdx;
+
+                // If the slot we get has not been claimed by anyone else,
+                // we will claim it and dequeue it, otherwise, keep searching next.
+                if (Slot(pSegment, relativeIdx).Claim(pDequeuedElement))
+                    return true;
+            }
+        }
+
+        /// <summary>
+        ///     Returns whether the mailbox is empty or not.
+        /// </summary>
+        bool IsEmpty() const
+        {
+            return (m_head == m_tail);
+        }
+
+    private:
+
+        /// <summary>
+        ///     Expires a slot.
+        /// </summary>
+        void ExpireSlot(Segment *pSegment, unsigned int relativeIdx)
+        {
+            pSegment->Dereference();
+        }
+
+        Segment *Grow(Segment *pPreviousSegment)
+        {
+            // This "Grow" function is always protected by the lock in "enqueue".
+
+            Segment *pNewSegment = _concrt_new Segment(m_pScheduler, m_affinitySet, m_segmentSize, pPreviousSegment->m_baseIdx + m_segmentSize);
+            m_pTailSegment = pNewSegment;
+            return pPreviousSegment->m_pNext = pNewSegment;
+        }
+
+        /// <summary>
+        ///     Performs one time demand initialization of the mailbox if the segments were set to be allocated on demand.
+        /// </summary>
+        void DemandInitialize()
+        {
+            if (m_pTailSegment == NULL)
+            {
+                Segment *pXchgSegment = reinterpret_cast<Segment *>(
+                    InterlockedCompareExchangePointer(reinterpret_cast<void * volatile *>(&m_pTailSegment),
+                                                      reinterpret_cast<Segment *>(FIELD_RESERVED),
+                                                      NULL)
+                    );
+
+                if (pXchgSegment == NULL)
+                {
+                    Segment *pNewSegment = _concrt_new Segment(m_pScheduler, m_affinitySet, m_segmentSize, 0);
+                    m_pTailSegment = pNewSegment;
+                    // sfence
+                    m_pHeadSegment = pNewSegment;
+                }
+            }
+
+            if (m_pHeadSegment == NULL)
+            {
+                _SpinWaitBackoffNone spinWait(_Sleep0);
+                while(m_pHeadSegment == NULL)
+                {
+                    spinWait._SpinOnce();
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Locates the appropriate mailbox segment for the specified absolute index.  This is only utilized during enqueue and dequeue and *NOT* during
+        ///     an arbitrary slot claim!
+        /// </summary>
+        Segment *LocateMailboxSegment(unsigned int absoluteIdx, bool fStartTail)
+        {
+            if (m_pHeadSegment == NULL)
+                DemandInitialize();
+
+            // lfence
+
+            Segment *pSegment = fStartTail ? m_pTailSegment : m_pHeadSegment;
+            ASSERT(absoluteIdx >= pSegment->m_baseIdx);
+
+            Segment *pPreviousSegment = pSegment;
+            while (pSegment && absoluteIdx >= pSegment->m_baseIdx + m_segmentSize)
+            {
+                pSegment = pSegment->m_pNext;
+                if (pSegment == NULL)
+                {
+                    ASSERT(fStartTail); // Only enqueue will "Grow" the queue.
+                    pSegment = Grow(pPreviousSegment);
+                }
+                pPreviousSegment = pSegment;
+            }
+
+            return pSegment;
+        }
+
+        //
+        // Determines the size of a mailbox segment.  Every mailbox pre-allocates a single segment.  The size should be large enough to amortize heap
+        // allocation but small enough not to be prohibitively waste memory.
+        //
+        // This value should be a power of two.
+        //
+        static const unsigned int s_segmentSize = 64;
+
+        // The scheduler to which the mailbox belongs
+        SchedulerBase *m_pScheduler;
+
+        // The mailbox's affinity set
+        QuickBitSet m_affinitySet;
+
+        // The size of segments for this mailbox.
+        unsigned int m_segmentSize;
+
+        // The head and tail segments for the mailbox.  These are within [m_head, m_tail].
+        Segment * volatile m_pTailSegment;
+        Segment * volatile m_pHeadSegment;
+
+        // The current head pointer
+        volatile unsigned int m_head;
+
+        // The current tail pointer
+        volatile unsigned int m_tail;
+
+        // Protect enqueue function, which should only accept one message for a time.
+        _NonReentrantLock m_enqueueLock;
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Platform.cpp

@@ -0,0 +1,921 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Platform.cpp
+//
+// Platform API abstraction.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#include "concrtinternal.h"
+#include <process.h>
+#include <Windows.h>
+
+#pragma warning (push)
+#pragma warning (disable: 4702 4100)
+
+namespace Concurrency { namespace details { namespace platform {
+
+/************** Events ***************************/
+
+/// <summary>
+/// Creates an auto reset event
+/// </summary>
+HANDLE __CreateAutoResetEvent(bool initialSet)
+{
+    DWORD flags = 0;
+
+    if (initialSet)
+    {
+        flags |= CREATE_EVENT_INITIAL_SET;
+    }
+
+    HANDLE hEvent = CreateEventExW(NULL, NULL, flags, STANDARD_RIGHTS_ALL | EVENT_MODIFY_STATE);
+    if (hEvent == NULL)
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    return hEvent;
+}
+
+/// <summary>
+/// Creates a manual reset event
+/// </summary>
+HANDLE __CreateManualResetEvent(bool initialSet)
+{
+    DWORD flags = CREATE_EVENT_MANUAL_RESET;
+
+    if (initialSet)
+    {
+        flags |= CREATE_EVENT_INITIAL_SET;
+    }
+
+    HANDLE hEvent = CreateEventExW(NULL, NULL, flags, STANDARD_RIGHTS_ALL | EVENT_MODIFY_STATE);
+    if (hEvent == NULL)
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    return hEvent;
+}
+
+/************** Tickcount ***************************/
+
+/// <summary>
+/// Gets the current tick count
+/// </summary>
+ULONGLONG __GetTickCount64()
+{
+    return GetTickCount64();
+}
+
+/************** Windows critical section ***************************/
+
+/// <summary>
+/// Initializes the critical section
+/// </summary>
+BOOL __InitializeCriticalSectionEx(CRITICAL_SECTION * cs, DWORD spinCount)
+{
+    return InitializeCriticalSectionEx(cs, spinCount, 0);
+}
+
+/************** Thread Local Storage ***************************/
+
+/// <summary>
+/// Allocates a TLS slot
+/// </summary>
+DWORD __TlsAlloc()
+{
+#if defined(_ONECORE)
+    // We use Fls (Fiber local storage) as TLS is not supported for MSDK.
+    DWORD index = FlsAlloc(nullptr);
+    if (index == FLS_OUT_OF_INDEXES)
+#else
+    // Use TLS for desktop because multiple schedulers are supported.
+    DWORD index = TlsAlloc();
+    if (index == TLS_OUT_OF_INDEXES)
+#endif
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    return index;
+}
+
+/// <summary>
+/// Frees a TLS slot
+/// </summary>
+void __TlsFree(DWORD index)
+{
+#if defined(_ONECORE)
+    if (index != FLS_OUT_OF_INDEXES)
+    {
+        FlsFree(index);
+        // Ignore error
+    }
+#else
+    TlsFree(index);
+#endif
+}
+
+/// <summary>
+/// Gets the value stored in the specified TLS slot
+/// </summary>
+PVOID __TlsGetValue(DWORD index)
+{
+#if defined(_ONECORE)
+    // Leave it up to the caller to decide if there was an error when
+    // the return value is NULL.
+    return FlsGetValue(index);
+#else
+    return TlsGetValue(index);
+#endif
+}
+
+/// <summary>
+/// Stores a value in the specified TLS slot
+/// </summary>
+void __TlsSetValue(DWORD index, PVOID value)
+{
+#if defined(_ONECORE)
+    if (!FlsSetValue(index, value))
+#else
+    if (!TlsSetValue(index, value))
+#endif
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+}
+
+/************** Thread Priority ***************************/
+
+/// <summary>
+/// Sets the thread priority
+/// </summary>
+void __SetThreadPriority(HANDLE hThread, int priority)
+{
+#if defined(_ONECORE)
+    // Dynamic thread priority modification is not supported under MSDK
+    ENSURE_NOT_APP();
+#else
+    if (SetThreadPriority(hThread, priority) == 0)
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+#endif // _ONECORE
+}
+
+/// <summary>
+/// Retrieves the thread priority
+/// </summary>
+int __GetThreadPriority(HANDLE hThread)
+{
+#if defined(_CRT_APP)
+    // MSDK does not support GetThreadPriority
+    ENSURE_NOT_APP();
+    return THREAD_PRIORITY_ERROR_RETURN;
+#else
+    return GetThreadPriority(hThread);
+#endif // defined(_CRT_APP)
+}
+
+/************** Thread Affinity ***************************/
+
+/// <summary>
+/// Retrieves the thread group affinity
+/// </summary>
+BOOL __GetThreadGroupAffinity(HANDLE hThread, PGROUP_AFFINITY affinity)
+{
+    // Don't do anything when targeting OneCore (We could set it to active processor mask in the future)
+#if !defined(_ONECORE)
+    CONCRT_VERIFY(GetThreadGroupAffinity(hThread, affinity));
+#endif // !defined(_ONECORE)
+
+    return 1;
+}
+
+/// <summary>
+/// Sets the thread group affinity
+/// </summary>
+BOOL __SetThreadGroupAffinity(HANDLE hThread, const GROUP_AFFINITY * affinity)
+{
+    // Don't do anything when targeting MSDK
+#if !defined(_ONECORE)
+    CONCRT_VERIFY(SetThreadGroupAffinity(hThread, affinity, NULL));
+#endif // !defined(_ONECORE)
+
+    return 1;
+}
+
+/************** System Info ***************************/
+
+/// <summary>
+/// Retrieves the information about the relationships of logical processors and related hardware
+/// </summary>
+PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX __GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP relation,  PDWORD retLength)
+{
+#if defined(_ONECORE)
+    // MSDK does not support this API. It is an error to call this API
+    ENSURE_NOT_APP();
+#else
+
+    ASSERT(retLength != nullptr);
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX pSysInfo = nullptr;
+
+    GetLogicalProcessorInformationEx(relation, NULL, retLength);
+
+    if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    DWORD len = *retLength;
+    ASSERT(len > 0);
+
+    pSysInfo = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) malloc(len);
+
+    if (pSysInfo == NULL)
+    {
+        throw std::bad_alloc();
+    }
+
+    if (!GetLogicalProcessorInformationEx(relation, pSysInfo, retLength))
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    return pSysInfo;
+#endif // defined(_ONECORE)
+}
+
+/// <summary>
+/// Retrieves the information about logical processors and related hardware
+/// </summary>
+PSYSTEM_LOGICAL_PROCESSOR_INFORMATION __GetLogicalProcessorInformation(PDWORD retLength)
+{
+#if defined(_ONECORE)
+    // MSDK does not support this API. It is an error to call this API
+    ENSURE_NOT_APP();
+#else
+#if (defined(_M_IX86) || defined(_M_X64))
+    ASSERT(retLength != nullptr);
+
+    GetLogicalProcessorInformation(NULL, retLength);
+    if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    DWORD len = *retLength;
+    ASSERT(len > 0);
+
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pSysInfo = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION) malloc(len);
+    if (pSysInfo == NULL)
+    {
+        throw std::bad_alloc();
+    }
+    if (!GetLogicalProcessorInformation(pSysInfo, retLength))
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+
+    return pSysInfo;
+#else
+    throw invalid_operation();
+#endif // (defined(_M_IX86) || defined(_M_X64))
+#endif // defined(_ONECORE)
+}
+
+/// <summary>
+/// Retrieves the processor group and number of the logical processor where the thread is running
+/// </summary>
+void __GetCurrentProcessorNumberEx(PPROCESSOR_NUMBER procNum)
+{
+#if defined(_ONECORE)
+    ENSURE_NOT_APP();
+#else
+    GetCurrentProcessorNumberEx(procNum);
+#endif // defined(_ONECORE)
+}
+
+/// <summary>
+/// Returns the highest numa node number
+/// </summary>
+ULONG __GetNumaHighestNodeNumber()
+{
+    ULONG highestNodeNumber;
+#if defined(_ONECORE)
+    // For MSDK we assume a single NUMA node
+    highestNodeNumber = 0;
+#else
+    if (!GetNumaHighestNodeNumber(&highestNodeNumber))
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+#endif // defined(_ONECORE)
+    return highestNodeNumber;
+}
+
+/************** Thread yield ***************************/
+
+/// <summary>
+/// Yield execution to another ready thread
+/// </summary>
+void __SwitchToThread()
+{
+#if defined(_ONECORE)
+    // TODO: Do we need to yield our time quantum?
+#else
+    SwitchToThread();
+#endif
+}
+
+/// <summary>
+/// Yield execution to another ready thread (ms is assumed to be 0 or 1)
+/// </summary>
+void __Sleep(DWORD ms)
+{
+    Sleep(ms);
+}
+
+//***********************************************/
+//   Timer                                       /
+//***********************************************/
+
+/// <summary>
+/// Creates a timer
+/// </summary>
+BOOL __CreateTimerQueueTimer(
+    PHANDLE phNewTimer,
+    HANDLE timerQueue,
+    WAITORTIMERCALLBACK  lpStartAddress,
+    PVOID lpParameter,
+    DWORD dueTime,
+    DWORD period,
+    ULONG flags
+)
+{
+#if defined(_ONECORE)
+    ENSURE_NOT_APP();
+#else
+    return CreateTimerQueueTimer(phNewTimer,
+                                timerQueue,
+                                lpStartAddress,
+                                lpParameter,
+                                dueTime,
+                                period,
+                                flags);
+#endif // defined(_ONECORE)
+}
+
+/// <summary>
+/// Deletes the timer
+/// </summary>
+void __DeleteTimerQueueTimer(HANDLE timerQueue, HANDLE hTimer, HANDLE completionEvent)
+{
+#if defined(_ONECORE)
+    ENSURE_NOT_APP();
+#else
+    for(int maximalRetry = 16; maximalRetry > 0; --maximalRetry)
+    {
+        if (!DeleteTimerQueueTimer(timerQueue, hTimer, completionEvent))
+        {
+            if (GetLastError() == ERROR_IO_PENDING)
+                break;
+        }
+        else
+        {
+            break;
+        }
+    }
+#endif // defined(_ONECORE)
+}
+
+/// <summary>
+/// Changes the due time of the timer.
+/// </summary>
+BOOL __ChangeTimerQueueTimer(HANDLE timerQueue, HANDLE hTimer, ULONG dueTime, ULONG period)
+{
+#if defined(_ONECORE)
+    ENSURE_NOT_APP();
+#else
+    return ChangeTimerQueueTimer(timerQueue, hTimer, dueTime, period);
+#endif // defined(_ONECORE)
+}
+
+//***********************************************/
+//   CreateThread                                /
+//***********************************************/
+
+/// <summary>
+/// Creates a thread
+/// </summary>
+HANDLE __CreateThread(LPSECURITY_ATTRIBUTES lpAttributes,
+    size_t stackSize,
+    LPTHREAD_START_ROUTINE startAddress,
+    LPVOID param,
+    DWORD flags,
+    LPDWORD threadId)
+{
+    return CreateThread(lpAttributes, stackSize, startAddress, param, flags, threadId);
+}
+
+/// <summary>
+/// Releases the thread handle
+/// </summary>
+void __CloseThreadHandle(HANDLE hThread)
+{
+    CloseHandle(hThread);
+}
+
+/// <summary>
+/// Waits for the thread to exit
+/// </summary>
+DWORD __WaitForThread(HANDLE hThread, DWORD timeout)
+{
+    return WaitForSingleObjectEx(hThread, timeout, FALSE);
+}
+
+/// <summary>
+/// Signals hSignal object and waits for hWait. Returns the reason for returning from wait
+/// </summary>
+DWORD __SignalObjectAndWait(HANDLE hSignal, HANDLE hWait, DWORD ms, BOOL alertable)
+{
+#if defined(_ONECORE)
+    SetEvent(hSignal);
+    return WaitForSingleObjectEx(hWait, ms, alertable);
+#else
+    return SignalObjectAndWait(hSignal, hWait, ms, alertable);
+#endif
+}
+
+
+//***********************************************/
+//   RegisterWaitForSingleObject                 /
+//***********************************************/
+
+/// <summary>
+/// Represents a collection of events and a background thread for handling those event notifications. Essentially
+/// it performs the equivalent functionality of RegisterWaitForSingleObject.
+/// </summary>
+class WaiterThread
+{
+public:
+    WaiterThread() : m_numEvents(0), m_numWaiting(0), m_pendingRemove(0)
+    {
+        for (int i = 0; i < MAXIMUM_WAIT_OBJECTS; i++)
+        {
+            m_waitHandles[i] = &m_eventData[i];
+        }
+    }
+
+    /// <summary>
+    /// Create the background thread
+    /// </summary>
+    void start()
+    {
+        // Create the background thread
+        HANDLE threadHandle = __CreateThread(NULL,
+                                            0,
+                                            WaiterThread::wait_bridge,
+                                            this,
+                                            0,
+                                            NULL);
+
+        __CloseThreadHandle(threadHandle);
+    }
+
+    /// <summary>
+    /// Indicate that the handler should be deleted when the background thread exits
+    /// </summary>
+    void stop()
+    {
+        auto waiterData = m_waitHandles[0];
+        waiterData->handler = nullptr;
+        notify(true);
+
+        // The background thread will eventually exit and reclaim this handler
+    }
+
+    /// <summary>
+    /// Indicates whether there are slots available in this handler
+    /// </summary>
+    bool is_available()
+    {
+        return m_numEvents < MAXIMUM_WAIT_OBJECTS;
+    }
+
+    /// <summary>
+    /// Adds a waiter for the given handle
+    /// </summary>
+    HANDLE add_handle(HANDLE hEvent, WAITORTIMERCALLBACK callback, PVOID context)
+    {
+        HANDLE hWait = nullptr;
+        {
+            _NonReentrantBlockingLock::_Scoped_lock lock(m_lock);
+
+            if (m_numEvents == 0)
+            {
+                // Create the wake event
+                HANDLE hWake = CreateEventExW(NULL, NULL, 0, STANDARD_RIGHTS_ALL | EVENT_MODIFY_STATE);
+                if (hWake== NULL)
+                {
+                    throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+                }
+
+                add_wait(hWake, wake_bridge, this);
+            }
+
+            // Add the user event
+            hWait = add_wait(hEvent, callback, context);
+
+            // Snap shot numWaiting
+            if (m_numWaiting == 0)
+            {
+                // Not started yet
+                m_numWaiting = m_numEvents;
+            }
+        }
+
+        // Notify the background thread after releasing the lock
+        notify(false);
+        return hWait;
+    }
+
+    /// <summary>
+    /// Remove the waiter for the given handle
+    /// </summary>
+    static void remove_handle(HANDLE hWait)
+    {
+        auto waiterData = static_cast<WAITER_DATA *>(hWait);
+        auto handler = static_cast<WaiterThread *>(waiterData->handler);
+        handler->remove_wait(waiterData);
+    }
+
+private:
+
+    typedef struct _WAITER_DATA
+    {
+        void * handler;
+        WAITORTIMERCALLBACK callback;
+        PVOID context;
+    } WAITER_DATA;
+
+    /// <summary>
+    /// Add the waiter to the list
+    /// </summary>
+    HANDLE add_wait(HANDLE hEvent, WAITORTIMERCALLBACK callback, PVOID context)
+    {
+        WAITER_DATA * waiterData = m_waitHandles[m_numEvents];
+        waiterData->callback = callback;
+        waiterData->context = context;
+        waiterData->handler = this;
+
+        m_hEvents[m_numEvents] = hEvent;
+        m_numEvents++;
+
+        return static_cast<HANDLE>(waiterData);
+    }
+
+    /// <summary>
+    /// Indicates that the waiter is to be removed from the list. The background
+    /// thread is notified which in turn would remove it from the list.
+    /// </summary>
+    void remove_wait(WAITER_DATA * waiterData)
+    {
+        waiterData->handler = nullptr;
+        notify(true);
+    }
+
+    /// <summary>
+    /// Notify the background thread
+    /// </summary>
+    void notify(bool isRemoval)
+    {
+        if (isRemoval)
+        {
+            // Wake up the background thread for the first removal
+            if (_InterlockedIncrement(&m_pendingRemove) == 1)
+            {
+                SetEvent(m_hEvents[0]);
+            }
+        }
+        else
+        {
+            // Avoid waking up the background thread for every event we add...
+            if (m_numEvents - m_numWaiting == 1)
+            {
+                SetEvent(m_hEvents[0]);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Invokes the callback
+    /// </summary>
+    void invoke_handler(DWORD index)
+    {
+        ASSERT(index < MAXIMUM_WAIT_OBJECTS);
+
+        auto waiterData = m_waitHandles[index];
+
+        // Skip the callback if the callback was removed
+        // Special case the wake handler
+        if ((index == 0) || (waiterData->handler != nullptr))
+        {
+            waiterData->callback(waiterData->context, FALSE);
+        }
+    }
+
+    /// <summary>
+    /// The main wait loop
+    /// </summary>
+    void wait_handler()
+    {
+        while (m_numWaiting > 0)
+        {
+            // Wait for the array of events
+            DWORD waitResult = WaitForMultipleObjectsEx((DWORD)m_numWaiting, m_hEvents, false, INFINITE, FALSE);
+            if (waitResult == WAIT_FAILED)
+            {
+                throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+            }
+
+            // Invoke the callback
+            DWORD waitHandleIndex = waitResult - WAIT_OBJECT_0;
+            ASSERT(waitHandleIndex < m_numWaiting);
+            invoke_handler(waitHandleIndex);
+
+            // If the callback removed a waiter or if it was already removed, process it here
+            if ((m_numWaiting > 0) && (WaitForSingleObjectEx(m_hEvents[0], 0, FALSE) == WAIT_OBJECT_0))
+            {
+                invoke_handler(0);
+            }
+        }
+    }
+
+    /// <summary>
+    /// static bridge that calls the wait loop
+    /// </summary>
+    static DWORD WINAPI wait_bridge(PVOID context)
+    {
+        auto handler = static_cast<WaiterThread *>(context);
+        handler->wait_handler();
+        delete handler;
+        return 0;
+    }
+
+    /// <summary>
+    /// The main handler for the back ground thread
+    /// </summary>
+    void wake_handler()
+    {
+        _NonReentrantBlockingLock::_Scoped_lock lock(m_lock);
+
+        auto pendingRemove = _InterlockedExchange(&m_pendingRemove, 0);
+
+        if (pendingRemove != 0)
+        {
+            process_remove();
+        }
+
+        // Update the num waiters (which is common for add and remove of handlers)
+        m_numWaiting = m_numEvents;
+    }
+
+    /// <summary>
+    /// Static bridge for the wake handler
+    /// </summary>
+    static void CALLBACK wake_bridge(PVOID context, BOOLEAN)
+    {
+        auto handler = static_cast<WaiterThread *>(context);
+        handler->wake_handler();
+    }
+
+    /// <summary>
+    /// Removes waiters and compacts the array of handles
+    /// </summary>
+    void process_remove()
+    {
+        // Walk all the handler and remove the ones that are marked (handler == nullptr)
+        // Skip the first event which is our wake handler
+        DWORD i = 1;
+        while (i < m_numEvents)
+        {
+            auto waiterData = m_waitHandles[i];
+
+            if (waiterData->handler == nullptr)
+            {
+                // Remove the event
+                CloseHandle(m_hEvents[i]);
+                m_numEvents--;
+
+                if (i != m_numEvents)
+                {
+                    // Swap the last event
+                    m_hEvents[i] = m_hEvents[m_numEvents];
+                    m_hEvents[m_numEvents] = NULL;
+
+                    m_waitHandles[i] = m_waitHandles[m_numEvents];
+                    m_waitHandles[m_numEvents] = waiterData;
+                }
+
+                // Process this event again
+                continue;
+            }
+
+            i++;
+        }
+
+        // If the last user event is removed attempt to remove the
+        // wake handler. It is not safe to remove the wake event without
+        // it being marked for removal by register_wait.
+        if ((m_numEvents == 1) && (m_waitHandles[0]->handler == nullptr))
+        {
+            CloseHandle(m_hEvents[0]);
+            m_hEvents[0] = NULL; // For debugging
+            m_numEvents--;
+        }
+
+        m_numWaiting = m_numEvents;
+    }
+
+
+private:
+
+    // Array of handles that is being waited on
+    HANDLE m_hEvents[MAXIMUM_WAIT_OBJECTS]{};
+
+    // The handlers corresponding to the event array (matching index)
+    WAITER_DATA * m_waitHandles[MAXIMUM_WAIT_OBJECTS];
+
+    // All the handles (including ones that are removed/not yet added etc).
+    WAITER_DATA m_eventData[MAXIMUM_WAIT_OBJECTS]{};
+
+    // Total number of events including the ones that are not yet waited upon
+    DWORD m_numEvents;
+
+    // The number of events that are being waited on
+    DWORD m_numWaiting;
+
+    // The number of pending remove requests
+    volatile long m_pendingRemove;
+
+    // Lock for insertion and deletion of handles
+    _NonReentrantBlockingLock m_lock;
+};
+
+/// <summary>
+/// Manages all the waiter threads. A waiter thread can only handle upto
+/// MAXIMUM_WAIT_OBJECTS events. This class maintains multiple such waiter threads
+/// </summary>
+class WaiterThreadPool
+{
+public:
+
+    WaiterThreadPool() : m_waiter(nullptr)
+    {
+    }
+
+    /// <summary>
+    /// Destructor
+    /// </summary>
+    ~WaiterThreadPool()
+    {
+        if (m_waiter != nullptr)
+        {
+            m_waiter->stop();
+        }
+    }
+
+    /// <summary>
+    /// Creates an event handler if required and registers a waiter for the given event in that handler
+    /// instance
+    /// </summary>
+    HANDLE add_waiter(HANDLE hSource, WAITORTIMERCALLBACK callback, PVOID context)
+    {
+        HANDLE hEvent;
+        if (!DuplicateHandle(GetCurrentProcess(),
+                            hSource,
+                            GetCurrentProcess(),
+                            &hEvent,
+                            0,
+                            FALSE,
+                            DUPLICATE_SAME_ACCESS))
+        {
+            throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+        }
+
+        HANDLE hWait = nullptr;
+        WaiterThread * newWaiter = nullptr;
+        {
+            _NonReentrantBlockingLock::_Scoped_lock lock(m_lock);
+
+            // Get the event handler
+            if ((m_waiter == nullptr) || (!m_waiter->is_available()))
+            {
+                if (m_waiter != nullptr)
+                {
+                    m_waiter->stop();
+                    m_waiter = nullptr;
+                }
+
+                m_waiter = new WaiterThread();
+                newWaiter = m_waiter;
+            }
+
+            // Add the wait event under the lock
+            hWait = m_waiter->add_handle(hEvent, callback, context);
+        }
+
+        // Start the handler after we release the lock
+        if (newWaiter != nullptr)
+        {
+            newWaiter->start();
+        }
+
+        return hWait;
+    }
+
+private:
+
+    WaiterThread * m_waiter;
+    _NonReentrantBlockingLock m_lock;
+};
+
+// Maintains a default global waiter threadpool instance
+// which will be released on process exit
+static WaiterThreadPool * s_waiterPool = nullptr;
+class DefaultWaiterPool
+{
+public:
+    DefaultWaiterPool()
+    {
+    }
+
+    ~DefaultWaiterPool()
+    {
+        if (s_waiterPool != nullptr)
+        {
+            delete s_waiterPool;
+            s_waiterPool = nullptr;
+        }
+    }
+
+    static WaiterThreadPool * get_waiter()
+    {
+        #pragma warning(suppress: 28112) // False positive warning, VSO-1807048
+        if (s_waiterPool == nullptr)
+        {
+            // Allocate on demand
+            auto waiterPool = new WaiterThreadPool;
+            if (_InterlockedCompareExchangePointer((volatile PVOID *)&s_waiterPool, waiterPool, nullptr) != nullptr)
+            {
+                delete waiterPool;
+            }
+        }
+
+        #pragma warning(suppress: 28112) // False positive warning, VSO-1807048
+        return s_waiterPool;
+    }
+};
+
+static DefaultWaiterPool s_defaultWaiterPool;
+
+HANDLE __RegisterWaitForSingleObject(HANDLE hEvent, WAITORTIMERCALLBACK callback, PVOID context)
+{
+    HANDLE hWait;
+#if defined(_ONECORE)
+    auto waiterPool = DefaultWaiterPool::get_waiter();
+    hWait = waiterPool->add_waiter(hEvent, callback, context);
+#else // !(_ONECORE)
+    // Request a thread pool thread to wait for this thread exit.
+    if (!RegisterWaitForSingleObject(&hWait,
+                    hEvent,
+                    callback,
+                    context, INFINITE, (WT_EXECUTEONLYONCE | WT_EXECUTEINWAITTHREAD)))
+    {
+        throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError()));
+    }
+#endif // !(_ONECORE)
+    return hWait;
+}
+
+void __UnregisterWait(HANDLE hWait)
+{
+#if defined(_ONECORE)
+    WaiterThread::remove_handle(hWait);
+#else
+    // Ignore both pseudo-failure (when a callback is already running) and real failure
+    // (as this is called by ExternalContextBase::ImplicitDetachHandlerXP() which cannot report failure).
+    (void) UnregisterWait(hWait);
+#endif // !(_ONECORE)
+}
+
+}}} // namespace Concurrency::details::platform
+
+#pragma warning (pop)

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/Platform.h

@@ -0,0 +1,206 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// Platform.h : abstracts the underlying platform APIs
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+// Windows headers that we need
+
+#include <Windows.h>
+#include <winnt.h>
+#include <OAIdl.h>
+
+#include <roapi.h>
+
+#undef Yield    // The windows headers #define Yield, a name we want to use
+
+#include <wmistr.h>
+#include <evntrace.h>
+#include <crtdefs.h>
+
+namespace Concurrency { namespace details { namespace platform {
+
+/****************** Events ***************************/
+
+/// <summary>
+/// Creates an auto reset event
+/// </summary>
+HANDLE __CreateAutoResetEvent(bool initialSet = false);
+
+/// <summary>
+/// Creates a manual reset event
+/// </summary>
+HANDLE __CreateManualResetEvent(bool initialSet = false);
+
+/************** Tickcount ***************************/
+
+/// <summary>
+/// Gets the current tick count
+/// </summary>
+ULONGLONG __GetTickCount64();
+
+/************** Windows critical section ***************************/
+
+/// <summary>
+/// Initializes the critical section
+/// </summary>
+BOOL __InitializeCriticalSectionEx(CRITICAL_SECTION * cs, DWORD spinCount);
+
+/************** Thread Local Storage *****************************/
+
+/// <summary>
+/// Allocates a TLS slot
+/// </summary>
+DWORD __TlsAlloc();
+
+/// <summary>
+/// Frees a TLS slot
+/// </summary>
+void __TlsFree(DWORD index);
+
+/// <summary>
+/// Gets the value stored in the specified TLS slot
+/// </summary>
+PVOID __TlsGetValue(DWORD index);
+
+/// <summary>
+/// Stores a value in the specified TLS slot
+/// </summary>
+void __TlsSetValue(DWORD index, PVOID value);
+
+/************** Thread Priority ***************************/
+
+/// <summary>
+/// Sets the thread priority
+/// </summary>
+void __SetThreadPriority(HANDLE hThread, int priority);
+
+/// <summary>
+/// Retrieves the thread priority
+/// </summary>
+int __GetThreadPriority(HANDLE hThread);
+
+/************** Thread Affinity ***************************/
+
+/// <summary>
+/// Retrieves the thread group affinity
+/// </summary>
+BOOL __GetThreadGroupAffinity(HANDLE hThread, PGROUP_AFFINITY affinity);
+
+/// <summary>
+/// Sets the thread group affinity
+/// </summary>
+BOOL __SetThreadGroupAffinity(HANDLE hThread, const GROUP_AFFINITY * affinity);
+
+/************** Thread yield ***************************/
+
+/// <summary>
+/// Yield execution to another ready thread
+/// </summary>
+void __SwitchToThread();
+
+/// <summary>
+/// Yield execution to another ready thread (ms is assumed to be 0 or 1)
+/// </summary>
+void __Sleep(DWORD ms);
+
+/************ Thread *********************************************/
+/// <summary>
+/// Creates a thread
+/// </summary>
+HANDLE __CreateThread(LPSECURITY_ATTRIBUTES lpAttributes,
+    size_t stackSize,
+    LPTHREAD_START_ROUTINE startAddress,
+    LPVOID param,
+    DWORD flags,
+    LPDWORD threadId);
+
+/// <summary>
+/// Releases the thread handle
+/// </summary>
+void __CloseThreadHandle(HANDLE hThread);
+
+/// <summary>
+/// Waits for the thread to exit
+/// </summary>
+DWORD __WaitForThread(HANDLE hThread, DWORD timeout);
+
+/// <summary>
+/// Signals hSignal object and waits for hWait. Returns the reason for returning from wait
+/// </summary>
+DWORD __SignalObjectAndWait(HANDLE hSignal, HANDLE hWait, DWORD ms, BOOL alertable);
+
+/************ Timer *********************************************/
+/// <summary>
+/// Creates a timer
+/// </summary>
+BOOL __CreateTimerQueueTimer(
+    PHANDLE phNewTimer,
+    HANDLE timerQueue,
+    WAITORTIMERCALLBACK  lpStartAddress,
+    PVOID lpParameter,
+    DWORD dueTime,
+    DWORD period,
+    ULONG flags
+);
+
+/// <summary>
+/// Deletes the timer
+/// </summary>
+void __DeleteTimerQueueTimer(HANDLE timerQueue, HANDLE hTimer, HANDLE completionEvent);
+
+/// <summary>
+/// Changes the due time of the timer.
+/// </summary>
+BOOL __ChangeTimerQueueTimer(HANDLE timerQueue, HANDLE hTimer, ULONG dueTime, ULONG period);
+
+/************** RegisterWaitForsingleObject ***********/
+
+/// <summary>
+/// Registers a waiter for the given handle. The callback is invoked when the handle is signalled
+/// </summary>
+HANDLE __RegisterWaitForSingleObject(HANDLE hEvent, WAITORTIMERCALLBACK callback, PVOID context);
+
+/// <summary>
+/// Removes the waiter for the given handle. Pending callbacks are cancelled. If a callback is
+/// already running then this will NOT wait for the callback to complete.
+/// </summary>
+void __UnregisterWait(HANDLE hWait);
+
+/************** System Info ***************************/
+
+/// <summary>
+/// Retrieves the information about the relationships of logical processors and related hardware
+/// </summary>
+PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX __GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP relation,  PDWORD retLength);
+
+/// <summary>
+/// Retrieves the information about logical processors and related hardware
+/// </summary
+PSYSTEM_LOGICAL_PROCESSOR_INFORMATION __GetLogicalProcessorInformation(PDWORD retLength);
+
+/// <summary>
+/// Retrieves the processor group and number of the logical processor where the thread is running
+/// </summary>
+void __GetCurrentProcessorNumberEx(PPROCESSOR_NUMBER procNum);
+
+/// <summary>
+/// Returns the highest numa node number
+/// </summary>
+ULONG __GetNumaHighestNodeNumber();
+
+/// <summary>
+/// Returns current thread ID
+/// </summary>
+#if defined(_CRTBLD) && !defined(CRTDLL2)
+_CONCRTIMP
+#endif
+long __cdecl GetCurrentThreadId();
+
+}}} // namespace Concurrency::details::platform

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/RealizedChore.cpp

@@ -0,0 +1,28 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// RealizedChore.cpp
+//
+// Miscellaneous implementations of things related to realized chores
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+    /// <summary>
+    ///     Method that executes the realized chore.  Not inline-able because debugger needs to
+    ///     locate executing realized chores by looking for this method's signature in the call
+    ///     frame.
+    /// </summary>
+    __declspec(noinline)
+    void RealizedChore::Invoke()
+    {
+        m_pFunction(m_pParameters);
+    }
+}

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/RealizedChore.h

@@ -0,0 +1,73 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// RealizedChore.h
+//
+// Header file containing the realized chore type declaration.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+
+    /// <summary>
+    ///     The class RealizedChore is used to implement light-weight tasks and Agents.
+    /// </summary>
+
+    class RealizedChore : public _Chore
+    {
+
+    public:
+
+        /// <summary>
+        ///     Constructor.
+        /// </summary>
+        RealizedChore(TaskProc pFunction, void* pParameters)
+        {
+            Initialize(pFunction, pParameters);
+        }
+
+        /// <summary>
+        ///     Initializes a realized chore, on construction and reuse.
+        /// </summary>
+        void Initialize(TaskProc pFunction, void* pParameters)
+        {
+            m_pFunction = pFunction;
+            m_pParameters = pParameters;
+            m_pNext = NULL;
+        }
+
+        /// <summary>
+        ///     Method that executes the realized chore.
+        /// </summary>
+        __declspec(noinline)
+        void Invoke();
+
+    private:
+        template <typename T> friend class SQueue;
+        template <class T> friend class LockFreeStack;
+
+        // Parameter to the chore procedure.
+        void *m_pParameters;
+
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+        union
+        {
+            // Next pointer for the locked runnables queue.
+            RealizedChore *m_pNext;
+
+            // List entry for lock free slist (free pool)
+            SLIST_ENTRY m_slNext;
+        };
+#pragma warning(pop)
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ResourceManager.h

@@ -0,0 +1,826 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ResourceManager.h
+//
+// Implementation of IResourceManager.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    #pragma warning(push)
+    #pragma warning(disable: 4265) // non-virtual destructor in base class
+    class ResourceManager final : public ::Concurrency::IResourceManager
+    {
+    public:
+        /// <summary>
+        ///     Increments the reference count on a resource manager.
+        /// </summary>
+        /// <returns>
+        ///     Returns the resulting reference count.
+        /// </returns>
+        virtual unsigned int Reference();
+
+        /// <summary>
+        ///     Decrements the reference count on a resource manager.
+        /// </summary>
+        /// <returns>
+        ///     Returns the resulting reference count.
+        /// </returns>
+        virtual unsigned int Release();
+
+        /// <summary>
+        ///     Associates an IScheduler with the ISchedulerProxy that represents the part
+        ///     of IResourceManager associated with the IScheduler.
+        /// </summary>
+        /// <param name="pScheduler">
+        ///     The scheduler to be associated.
+        /// </param>
+        /// <param name="version">
+        ///     The version of the RM<->Scheduler communication channel that is being utilized.
+        /// </param>
+        virtual ISchedulerProxy * RegisterScheduler(IScheduler *pScheduler, unsigned int version);
+
+        /// <summary>
+        ///     Returns the number of nodes available to the Resource Manager.
+        /// </summary>
+        /// <returns>
+        ///     The number of nodes available to the Resource Manager.
+        /// </returns>
+        /**/
+        virtual unsigned int GetAvailableNodeCount() const
+        {
+            // TRANSITION: At some point when RM honors process affinity, etc..., go back and ensure that this is the correct value to return!
+            return m_nodeCount;
+        }
+
+        /// <summary>
+        ///     Returns the first node in enumeration order as defined by the Resource Manager.
+        /// </summary>
+        /// <returns>
+        ///     The first node in enumeration order as defined by the Resource Manager.
+        /// </returns>
+        /// <seealso cref="ITopologyNode::GetExecutionResourceCount Method"/>
+        /**/
+        virtual ITopologyNode* GetFirstNode() const
+        {
+            return m_pGlobalNodes->m_pTopologyObject;
+        }
+
+        /// <summary>
+        ///     Creates an instance of the resource manager.
+        /// </summary>
+        static ResourceManager* CreateSingleton();
+
+        /// <summary>
+        ///     Returns the OS version.
+        /// </summary>
+        static IResourceManager::OSVersion Version();
+
+        /// <summary>
+        ///     Returns the number of nodes (processor packages or NUMA nodes)
+        /// </summary>
+        static unsigned int GetNodeCount();
+
+        /// <summary>
+        ///     Returns the number of cores.
+        /// </summary>
+        static unsigned int GetCoreCount();
+
+        /// <summary>
+        ///     Returns a pointer to the manager of factories for thread proxies.
+        /// </summary>
+        ThreadProxyFactoryManager * GetThreadProxyFactoryManager() { return &m_threadProxyFactoryManager; }
+
+        /// <summary>
+        ///     These APIs return unique identifiers for use by schedulers, execution contexts and thread proxies.
+        /// </summary>
+        static unsigned int GetSchedulerId() { return InterlockedIncrement(&s_schedulerIdCount); }
+        static unsigned int GetExecutionContextId() { return InterlockedIncrement(&s_executionContextIdCount); }
+        static unsigned int GetThreadProxyId() { return InterlockedIncrement(&s_threadProxyIdCount); }
+
+        /// <summary>
+        ///     These APIs restrict the execution resources used by the Concurrency Runtime's internal worker threads to the affinity set specified.
+        /// </summary>
+        static void SetTaskExecutionResources(DWORD_PTR dwAffinityMask);
+        static void SetTaskExecutionResources(USHORT count, PGROUP_AFFINITY pGroupAffinity);
+
+        /// <summary>
+        ///     The main allocation routine that allocates cores for a newly created scheduler proxy.
+        /// </summary>
+        ExecutionResource * PerformAllocation(SchedulerProxy *pSchedulerProxy, bool fInitialAllocation, bool fSubscribeCurrentThread);
+
+        /// <summary>
+        ///     This API registers the current thread with the resource manager, associating it with this scheduler proxy,
+        ///     and returns an instance of IExecutionResource back to the scheduler, for bookkeeping and maintenance.
+        /// </summary>
+        ExecutionResource * SubscribeCurrentThread(SchedulerProxy *pSchedulerProxy);
+
+        /// <summary>
+        ///     The allocation routine that allocates a single core for a newly registered external thread.
+        /// </summary>
+        ExecutionResource * PerformExternalThreadAllocation(SchedulerProxy *pSchedulerProxy);
+
+        /// <summary>
+        ///     Removes an execution resource that was created for an external thread.
+        /// </summary>
+        void RemoveExecutionResource(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Called in order to notify the resource manager that the given scheduler is shutting down.  This
+        ///     will cause the resource manager to immediately reclaim all resources granted to the scheduler.
+        /// </summary>
+        void Shutdown(SchedulerProxy *pProxy);
+
+        /// <summary>
+        ///     Called by a scheduler in order make an initial request for an allocation of virtual processors.  The request
+        ///     is driven by policies within the scheduler queried via the IScheduler::GetPolicy method.  If the request
+        ///     can be satisfied via the rules of allocation, it is communicated to the scheduler as a call to
+        ///     IScheduler::AddVirtualProcessors.
+        /// </summary>
+        /// <param name="pProxy">
+        ///     The scheduler proxy that is making the allocation request.
+        /// </param>
+        /// <param name="doSubscribeCurrentThread">
+        ///     Whether to subscribe the current thread and account for it during resource allocation.
+        /// </param>
+        /// <returns>
+        ///     The IExecutionResource instance representing current thread if doSubscribeCurrentThread was true; NULL otherwise.
+        /// </returns>
+        IExecutionResource * RequestInitialVirtualProcessors(SchedulerProxy *pProxy, bool doSubscribeCurrentThread);
+
+        /// <summary>
+        ///     Debug CRT test hook to create artificial topologies. With the retail CRT, this API simply returns.
+        /// </summary>
+        virtual void CreateNodeTopology(unsigned int nodeCount, unsigned int *pCoreCount, unsigned int **pNodeDistance, unsigned int *pProcessorGroups);
+
+        /// <summary>
+        ///     The API returns after ensuring that all store buffers on processors that are running threads from this process,
+        ///     are flushed. It does this by either calling a Win32 API that explicitly does this on versions of Windows that
+        ///     support the functionality, or by changing the protection on a page that is locked into the working set, forcing
+        ///     a TB flush on all processors in question.
+        /// </summary>
+        void FlushStoreBuffers();
+
+        /// <summary>
+        ///     Returns the TLS slot where information about an execution resource is supposed to be stored.
+        /// </summary>
+        /// <remarks>
+        ///     Used to check whether SubscribeCurrentThread already has an execution resource on which it is running.
+        /// </remarks>
+        DWORD GetExecutionResourceTls() const
+        {
+            return m_threadProxyFactoryManager.GetExecutionResourceTls();
+        }
+
+        /// <summary>
+        ///     Decrements the use count on a particular global core. Used for removal of external threads.
+        /// </summary>
+        void DecrementCoreUseCount(unsigned int nodeId, unsigned int coreIndex)
+        {
+            // NOTE: Caller is responsible for holding the RM lock!
+            GlobalCore * pGlobalCore = &(m_pGlobalNodes[nodeId].m_pCores[coreIndex]);
+            pGlobalCore->m_useCount--;
+        }
+
+        /// <summary>
+        ///     Returns the current thread's node id and core id (relative to that node).
+        /// </summary>
+        unsigned int GetCurrentNodeAndCore(unsigned int * pCore);
+
+        /// <summary>
+        ///     Returns the global subscription level of the underlying core.
+        /// </summary>
+        unsigned int CurrentSubscriptionLevel(unsigned int nodeId, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Returns true if there are any schedulers in the RM that need notifications sent, false, otherwise.
+        /// </summary>
+        bool SchedulersNeedNotifications()
+        {
+            return (m_numSchedulersNeedingNotifications > 0);
+        }
+
+        /// <summary>
+        ///     Returns the number of schedulers that need core busy/idle notifications.
+        /// </summary>
+        unsigned int GetNumSchedulersForNotifications()
+        {
+            return m_numSchedulersNeedingNotifications;
+        }
+
+        /// <summary>
+        ///     Wakes up the dynamic RM worker from a wait state.
+        /// </summary>
+        void WakeupDynamicRMWorker()
+        {
+            SetEvent(m_hDynamicRMEvent);
+        }
+
+        /// <summary>
+        ///     Sends NotifyResourcesExternallyIdle/NotifyResourcesExternallyBusy notifications to the schedulers that
+        ///     qualify for them, to let them know that the hardware resources allocated to them are in use or out of use
+        ///     by other schedulers that share those resources.
+        /// </summary>
+        /// <param name ="pNewlyAllocatedProxy">
+        ///     The newly allocated scheduler proxy, if one was just allocated.
+        /// </param>
+        void SendResourceNotifications(SchedulerProxy * pNewlyAllocatedProxy = NULL);
+
+        /// <summary>
+        ///     Allocates and initializes the data structure that will represent the allocated nodes for a scheduler proxy.
+        ///     This function is called the first time a scheduler proxy requests an allocation.
+        /// </summary>
+        SchedulerNode * CreateAllocatedNodeData();
+
+        /// <summary>
+        ///     Destroys the data structures representing nodes/cores allocated to a scheduler proxy when the proxy has
+        ///     shutdown.
+        /// </summary>
+        void DestroyAllocatedNodeData(SchedulerNode * pAllocatedNodes);
+
+        /// <summary>
+        ///     Gets the next node in enumeration order.
+        /// </summary>
+        GlobalNode *GetNextGlobalNode(const GlobalNode *pNode)
+        {
+            unsigned int idx = (unsigned int)((pNode - m_pGlobalNodes) + 1);
+            return ((idx < m_nodeCount) ? &m_pGlobalNodes[idx] : NULL);
+        }
+
+    private:
+
+        // State that controls what the dynamic RM worker thread does.
+        enum DynamicRMWorkerState
+        {
+            Standby,
+            LoadBalance,
+            Exit
+        };
+
+        struct AffinityRestriction
+        {
+            AffinityRestriction() :
+                m_count(0),
+                m_pGroupAffinity(NULL)
+            {
+            }
+
+            AffinityRestriction(USHORT count, HardwareAffinity * pGroupAffinity) :
+                m_count(count),
+                m_pGroupAffinity(pGroupAffinity)
+            {
+            }
+
+            ~AffinityRestriction()
+            {
+                delete m_pGroupAffinity;
+            }
+
+            HardwareAffinity * FindGroupAffinity(USHORT group)
+            {
+                for (USHORT i = 0; i < m_count; ++i)
+                {
+                    if (m_pGroupAffinity[i].GetGroup() == group)
+                    {
+                        return &m_pGroupAffinity[i];
+                    }
+                }
+                return NULL;
+            }
+
+            void ApplyAffinityLimits(PGROUP_AFFINITY pGroupAffinity)
+            {
+                HardwareAffinity * pAffinity = FindGroupAffinity(pGroupAffinity->Group);
+                if (pAffinity != NULL)
+                {
+                    pGroupAffinity->Mask &= pAffinity->GetMask();
+                }
+                else
+                {
+                    // The user has not asked for this group to be included.
+                    pGroupAffinity->Mask = 0;
+                }
+            }
+
+            USHORT GetCount()
+            {
+                return m_count;
+            }
+
+        private:
+            USHORT m_count;
+            HardwareAffinity * m_pGroupAffinity;
+        };
+
+#if defined(CONCRT_TRACING)
+
+        struct GlobalCoreData
+        {
+            unsigned char m_nodeIndex;
+            unsigned char m_coreIndex;
+            unsigned char m_useCount;
+            unsigned char m_idleSchedulers;
+        };
+
+        // Maintains a trace for every core removed during preprocessing.
+        struct PreProcessingTraceData
+        {
+            SchedulerProxy * m_pProxy;
+            unsigned char m_nodeIndex;
+            unsigned char m_coreIndex;
+            bool m_fMarkedAsOwned : 1;
+            bool m_fBorrowedCoreRemoved : 1;
+            bool m_fSharedCoreRemoved : 1;
+            bool m_fIdleCore : 1;
+        };
+
+        // Maintains a trace for each core allocation
+        struct DynamicAllocationTraceData
+        {
+            SchedulerProxy * m_pGiver; // this is null if the core was unused or idle
+            SchedulerProxy * m_pReceiver;
+            unsigned char m_round;
+            unsigned char m_nodeIndex;
+            unsigned char m_coreIndex;
+            bool m_fUnusedCoreMigration : 1;
+            bool m_fIdleCoreSharing : 1;
+            bool m_fBorrowedByGiver : 1;
+            bool m_fIdleOnGiver : 1;
+        };
+
+#endif
+
+        //
+        // Private data
+        //
+
+        // The singleton resource manager instance.
+        static ResourceManager *s_pResourceManager;
+
+        // System and process affinities, either when the RM is created or an affinity limitation is specified. Note that this is limited to 64 cores on
+        // >64 core systems; by default the OS puts a process in a single group. For processes on a >64 core system, the system affinity mask reflects the
+        // affinity of the process in that group.
+        static DWORD_PTR s_processAffinityMask;
+        static DWORD_PTR s_systemAffinityMask;
+
+        // Pointer to a data structure that is initialized if the task execution affinity for ConcRT is limited via the API SetTaskExecutionResources.
+        static AffinityRestriction * s_pUserAffinityRestriction;
+        // Pointer to a data structure that is initialized if the process affinity is different from the system affinity at the time the topology is created.
+        static AffinityRestriction * s_pProcessAffinityRestriction;
+
+        // A lock that protects setting of the singleton instance.
+        static _StaticLock s_lock;
+
+        // The total number of hardware threads available to the RM.
+        static unsigned int s_coreCount;
+
+        // The number of nodes that hardware threads are grouped into.
+        static unsigned int s_nodeCount;
+
+        // Operating system characteristics.
+        static IResourceManager::OSVersion s_version;
+
+        // Termination indicator
+        static volatile LONG s_terminating;
+
+        // Static counters to generate unique identifiers.
+        static volatile LONG s_schedulerIdCount;
+        static volatile LONG s_executionContextIdCount;
+        static volatile LONG s_threadProxyIdCount;
+
+        // Variables used to obtain information about the topology of the system.
+        static DWORD s_logicalProcessorInformationLength;
+        static PSYSTEM_LOGICAL_PROCESSOR_INFORMATION s_pSysInfo;
+
+        // Constants that are used as parameters to the ReleaseSchedulerResources API
+        static const unsigned int ReleaseCoresDownToMin = static_cast<unsigned int>(-1);
+        static const unsigned int ReleaseOnlyBorrowedCores = static_cast<unsigned int>(-2);
+
+        // RM instance reference count
+        volatile LONG m_referenceCount;
+
+        // Number of schedulers currently using resources granted by the RM.
+        unsigned int m_numSchedulers;
+
+        // The maximum number of schedulers the dynamic RM worker has resources to handle, at any time. This can
+        // change during the lifetime of the process.
+        unsigned int m_maxSchedulers;
+
+        // Number of schedulers in the RM that need resource notifications.
+        unsigned int m_numSchedulersNeedingNotifications;
+
+        // The number of processor packages or NUMA nodes (whichever is greater) on the system. This is a mirror of s_nodeCount above.
+        unsigned int m_nodeCount;
+
+        // The number of HW threads on the machine. This is a mirror of s_coreCount above.
+        unsigned int m_coreCount;
+
+        // A field used during core migration to keep track of the number of idle cores - cores such that
+        // all schedulers they are assigned to are not using them.
+        unsigned int m_dynamicIdleCoresAvailable;
+
+        // Keeps track of the allocation round during dynamic core migration. Used for tracing.
+        unsigned int m_allocationRound;
+
+        // A state variable that is used to control how the dynamic worker behaves.
+        volatile DynamicRMWorkerState m_dynamicRMWorkerState;
+
+        // A lock that protects resource allocation and deallocation.
+        _NonReentrantBlockingLock m_lock;
+
+        // The global allocation map for all schedulers - array of processor nodes.
+        GlobalNode * m_pGlobalNodes;
+
+        // Handle to the dynamic RM worker thread.
+        HANDLE m_hDynamicRMThreadHandle;
+
+        // An event that is used to control the dynamic RM worker thread.
+        HANDLE m_hDynamicRMEvent;
+
+        // Data used for static and/or dynamic allocation.
+        AllocationData ** m_ppProxyData;
+        DynamicAllocationData ** m_ppGivingProxies;
+        DynamicAllocationData ** m_ppReceivingProxies;
+
+        // Lists to hold scheduler proxies.
+        List<SchedulerProxy, CollectionTypes::Count> m_schedulers;
+
+        // A collection of thread proxy factories
+        ThreadProxyFactoryManager m_threadProxyFactoryManager;
+
+        // A pointer to a page that is used to flush write buffers on versions of Windows < 6000.
+        char* m_pPageVirtualProtect;
+
+#if defined(CONCRT_TRACING)
+
+        // Captures the initial global state during the DRM phase.
+        GlobalCoreData * m_drmInitialState;
+        unsigned int m_numTotalCores;
+
+        // Maintains a trace for every core removed during preprocessing.
+        PreProcessingTraceData m_preProcessTraces[100];
+        unsigned int m_preProcessTraceIndex;
+
+        // Maintains a trace for each core allocation
+        DynamicAllocationTraceData m_dynAllocationTraces[100];
+        unsigned int m_dynAllocationTraceIndex;
+#endif
+
+        //
+        // Private methods
+        //
+
+        // Private constructor.
+        ResourceManager();
+
+        // Private destructor.
+        ~ResourceManager();
+
+        /// <summary>
+        ///     Initializes static variables related to the operating system version.
+        /// </summary>
+        static void RetrieveSystemVersionInformation();
+
+        /// <summary>
+        ///     Captures the process affinity if it is not equal to the system affinity.
+        /// </summary>
+        static void CaptureProcessAffinity();
+
+        /// <summary>
+        ///     Modify the passed in affinity based on any user or process affinity restrictions.
+        /// </summary>
+        static void ApplyAffinityRestrictions(PGROUP_AFFINITY pGroupAffinity);
+        static void ApplyAffinityRestrictions(PULONG_PTR pProcessorMask);
+
+        /// <summary>
+        ///     Retrieves a buffer from the operating system that contains topology information.
+        /// </summary>
+        static void GetTopologyInformation(LOGICAL_PROCESSOR_RELATIONSHIP relationship);
+
+        /// <summary>
+        ///     Cleans up the variables that store operating system topology information.
+        /// </summary>
+        static void CleanupTopologyInformation();
+
+        /// <summary>
+        ///     Initializes static information related to the operating system and machine topology.
+        /// </summary>
+        static void InitializeSystemInformation(bool fSaveTopologyInfo = false);
+
+        /// <summary>
+        ///     Creates a scheduler proxy for an IScheduler that registers with the RM.
+        /// </summary>
+        SchedulerProxy* CreateSchedulerProxy(IScheduler *pScheduler);
+
+        /// <summary>
+        ///     Increments the reference count to RM but does not allow a 0 to 1 transition.
+        /// </summary>
+        /// <returns>
+        ///     True if the RM was referenced; false, if the reference count was 0.
+        /// </returns>
+        bool SafeReference();
+
+        /// <summary>
+        ///     Creates a structure of nodes and cores based on the machine topology.
+        /// </summary>
+        void DetermineTopology();
+
+    /// <summary>
+    ///     Instructs existing schedulers to release cores. Then tries to allocate available cores for the new scheduler.
+    ///     The parameter 'numberToFree' can have a couple of special values:
+    ///         ReleaseCoresDownToMin - scheduler should release all cores above its minimum. Preference is giving to releasing borrowed cores.
+    ///         ReleaseOnlyBorrowedCores - scheduler should release all its borrowed cores.
+    ///     If the parameter is not a special value, a call should have previously been made for this scheduler with the value ReleaseOnlyBorrowedCores.
+    ///     i.e., the scheduler should not have any borrowed cores to release.
+    /// </summary>
+        unsigned int ReleaseCoresOnExistingSchedulers(SchedulerProxy * pNewProxy, unsigned int request, unsigned int numberToFree);
+
+        /// <summary>
+        ///     Tries to redistribute cores allocated to all schedulers, proportional to each schedulers value for 'DesiredHardwareThreads',
+        ///     and allocates any freed cores to the new scheduler.
+        /// </summary>
+        unsigned int RedistributeCoresAmongAll(SchedulerProxy* pSchedulerProxy, unsigned int allocated, unsigned int minimum, unsigned int desired);
+
+        /// <summary>
+        ///     Reserves cores for the new scheduler at higher use counts - this is used only to satisfy MinHWThreads.
+        /// </summary>
+        unsigned int ReserveAtHigherUseCounts(SchedulerProxy * pSchedulerProxy, unsigned int request);
+
+        /// <summary>
+        ///     Worker routine that does actual core reservation, using the supplied use count. It tries to
+        ///     pack reserved cores onto nodes by preferring nodes where more free cores are available.
+        /// </summary>
+        unsigned int ReserveCores(SchedulerProxy * pSchedulerProxy, unsigned int request, unsigned int useCount);
+
+        /// <summary>
+        ///     Instructs a scheduler proxy to free up a fixed number of resources. This is only a temporary release of resources. The
+        ///     use count on the global core is decremented and the scheduler proxy remembers the core as temporarily released. At a later
+        ///     point, the release is either confirmed or rolled back, depending on whether the released core was used to satisfy a
+        ///     different scheduler's allocation.
+        /// </summary>
+        /// <param name="pReceivingProxy">
+        ///     The scheduler proxy for which the cores are being stolen - this is the proxy that is being currently allocated to.
+        /// </param>
+        /// <param name="pGivingProxy">
+        ///     The scheduler proxy that needs to free up resources.
+        /// </param>
+        /// <param name="numberToFree">
+        ///     The number of resources to free. This parameter can have a couple of special values:
+        ///         ReleaseCoresDownToMin - scheduler should release all cores above its minimum. Preference is giving to releasing borrowed cores.
+        ///         ReleaseOnlyBorrowedCores - scheduler should release all its borrowed cores.
+        ///     If the parameter is not a special value, a call should have previously been made for this scheduler with the value ReleaseOnlyBorrowedCores.
+        ///     i.e., the scheduler should not have any borrowed cores to release.
+        /// </param>
+        bool ReleaseSchedulerResources(SchedulerProxy * pReceivingProxy, SchedulerProxy *pGivingProxy, unsigned int numberToFree);
+
+        /// <summary>
+        ///     Called to claim back any previously released cores that were not allocated to a different scheduler. If released
+        ///     cores were allocated (stolen), the proxy needs to notify its scheduler to give up the related virtual processor
+        ///     roots.
+        /// <summary>
+        void CommitStolenCores(SchedulerProxy * pSchedulerProxy);
+
+        /// <summary>
+        ///     Starts up the dynamic RM worker thread if it is on standby, or creates a thread if one is not already created.
+        ///     The worker thread wakes up at fixed intervals and load balances resources among schedulers, until it it put on standby.
+        /// </summary>
+        void CreateDynamicRMWorker();
+
+        /// <summary>
+        ///     Routine that performs dynamic resource management among existing schedulers at fixed time intervals.
+        /// </summary>
+        void DynamicResourceManager();
+
+        /// <summary>
+        ///     Performs a dynamic resource allocation based on feedback from hill climbing.
+        /// </summary>
+        void DoCoreMigration();
+
+        /// <summary>
+        ///     When the number of schedulers in the RM goes from 2 to 1, this routine is invoked to make sure the remaining scheduler
+        ///     has its desired number of cores, before putting the dynamic RM worker on standby. It is also called when there is just
+        ///     one scheduler with external subscribed threads that it removes -> there is a chance that this move may allow us to allocate
+        ///     more vprocs.
+        /// </summary>
+        bool DistributeCoresToSurvivingScheduler();
+
+        /// <summary>
+        ///     This API is called by the dynamic RM worker thread when it starts up, and right after its state changed to
+        ///     LoadBalance after being on Standby for a while. We need to find the existing schedulers, and discard the
+        ///     statistics they have collected so far if any. Either we've never collected statistics for this scheduler before,
+        ///     or too much/too little time has passed since we last collected statistics, and this information cannot be trusted.
+        /// </summary>
+        void DiscardExistingSchedulerStatistics();
+
+        /// <summary>
+        ///     Ensures that the memory buffers needed for static and dynamic RM are of the right size, and initializes them.
+        /// </summary>
+        void InitializeRMBuffers();
+
+        /// <summary>
+        ///     Populates data needed for allocation (static or dynamic).
+        /// </summary>
+        void PopulateCommonAllocationData(unsigned int index, SchedulerProxy * pSchedulerProxy, AllocationData * pAllocationData);
+
+        /// <summary>
+        ///     Captures data needed for static allocation, for all existing schedulers. This includes determining which
+        ///     cores on a scheduler are idle.
+        ///     A number of preprocessing steps are are also preformed before we are ready to allocate cores for a new scheduler.
+        ///
+        ///     - If a borrowed core is now in use by the other scheduler(s) that own that core, it is taken away.
+        ///     - If the scheduler with the borrowed core is now the only scheduler using the core, it is not considered borrowed any more.
+        /// </summary>
+        void SetupStaticAllocationData(SchedulerProxy * pNewProxy, bool fSubscribeCurrentThread);
+
+        /// <summary>
+        ///     Captures data needed for dynamic allocation for all existing schedulers. This includes gathering statistics
+        ///     and invoking a per scheduler hill climbing instance, to get a suggested future allocation. Also, determines how may
+        ///     idle cores a scheduler has.
+        /// </summary>
+        void PopulateDynamicAllocationData();
+
+        /// <summary>
+        ///     Undo global state that was initialized to perform static allocation or dynamic core migration.
+        /// </summary>
+        void ResetGlobalAllocationData();
+
+        /// <summary>
+        ///     Resets state that was set on the global cores during static or dynamic allocation.
+        /// </summary>
+        void ResetGlobalState();
+
+        /// <summary>
+        ///     Toggles the idle state on a core and updates tracking counts.
+        /// </summary>
+        void ToggleRMIdleState(SchedulerNode * pAllocatedNode, SchedulerCore * pAllocatedCore,
+                                GlobalNode * pGlobalNode, GlobalCore * pGlobalCore, AllocationData * pDRMData);
+
+        /// <summary>
+        ///     A number of preprocessing steps are performed before we are ready to allocate cores. They include handling of borrowed and idle,
+        ///     cores, as follows:
+        ///     - If a borrowed core is now in use by the other scheduler(s) that own that core, it is taken away.
+        ///     - If the scheduler with the borrowed core is now the only scheduler using the core, it is not considered borrowed anymore.
+        /// </summary>
+        void PreProcessStaticAllocationData();
+
+        /// <summary>
+        ///     A number of preprocessing steps are preformed before we are ready to migrate cores. They include handling of borrowed, idle,
+        ///     and shared cores, as follows:
+        ///
+        ///     - If a borrowed core is now in use by the other scheduler(s) that own that core, it is taken away.
+        ///     - If the scheduler with the borrowed core is now the only scheduler using the core, it is not considered borrowed anymore.
+        ///     - If hill climbing has suggested an allocation increase for a scheduler that has idle cores, or an allocation decrease that
+        ///         does not take away all its idle cores, the RM overrides it, setting the suggested allocation for that scheduler to
+        ///         max(minCores, allocatedCores - idleCores).
+        ///
+        ///       The new value of suggested allocation is used for the following:
+        ///     - If the suggested allocation is less than the current allocation for a scheduler that has shared cores (cores oversubscribed
+        ///         with a different scheduler), those cores are taken away here, since we want to minimize sharing.
+        /// </summary>
+        void PreProcessDynamicAllocationData();
+
+        /// <summary>
+        ///     Preprocessing steps for borrowed cores - both static and dynamic allocation start out with a call to this API.
+        /// </summary>
+        void HandleBorrowedCores(SchedulerProxy * pSchedulerProxy, AllocationData * pAllocationData);
+
+        /// <summary>
+        ///     Preprocessing steps for shared cores - this is used during dynamic core migration.
+        /// </summary>
+        void HandleSharedCores(SchedulerProxy * pSchedulerProxy, DynamicAllocationData * pAllocationData);
+
+        /// <summary>
+        ///     This routine increases the suggested allocation to desired, for schedulers with the following characteristics:
+        ///     1) Hill climbing has *not* recommended an allocation decrease.
+        ///     2) They are using all the cores allocated to them (no idle cores).
+        ///     In the second round of core migration, we try to satisfy these schedulers' desired allocation.
+        /// </summary>
+        void IncreaseFullyLoadedSchedulerAllocations();
+
+        /// <summary>
+        ///     Decides on the number of additional cores to give a set of schedulers, given what the schedulers need and what is available.
+        /// </summary>
+        unsigned int AdjustDynamicAllocation(unsigned int coresAvailable, unsigned int coresNeeded, unsigned int numReceivers);
+
+        /// <summary>
+        ///     Initializes receiving proxy data in preparation for core transfer. Calculates the number of partially filled nodes
+        ///     for schedulers that are receiving cores, and sorts the receiving proxy data in increasing order of partial nodes.
+        /// </summary>
+        /// <returns>
+        ///     Number of receivers that still need cores (allocation field of the receiving proxy data > 0).
+        /// </returns>
+        unsigned int PrepareReceiversForCoreTransfer(unsigned int numReceivers);
+
+        /// <summary>
+        ///     Assigns one core at a time to a partially filled node on a receiving scheduler proxy, if possible
+        /// </summary>
+        bool FindCoreForPartiallyFilledNode(unsigned int& unusedCoreQuota,
+                                            unsigned int& usedCoreQuota,
+                                            DynamicAllocationData * pReceivingProxyData,
+                                            unsigned int numGivers);
+
+        /// <summary>
+        ///     Attempts to assign cores to a receiver on a single empty node, taking cores from multiple givers if necessary.
+        /// </summary>
+        unsigned int FindBestFitExclusiveAllocation(unsigned int& unusedCoreQuota,
+                                                    unsigned int& usedCoreQuota,
+                                                    DynamicAllocationData * pReceivingProxyData,
+                                                    unsigned int remainingReceivers,
+                                                    unsigned int numGivers);
+
+        /// <summary>
+        ///     Distributes unused cores and cores from scheduler proxies that are willing to give up cores to scheduler proxies that
+        ///     need cores.
+        /// </summary>
+        void DistributeExclusiveCores(unsigned int totalCoresNeeded,
+                                      unsigned int unusedCoreQuota,
+                                      unsigned int usedCoreQuota,
+                                      unsigned int numReceivers,
+                                      unsigned int numGivers);
+
+        /// <summary>
+        ///     Attempts to assign cores to a receiver on a single empty node, using idle cores.
+        /// </summary>
+        unsigned int FindBestFitIdleAllocation(unsigned int idleCoresAvailable, DynamicAllocationData * pReceivingProxyData, unsigned int remainingReceivers);
+
+        /// <summary>
+        ///     Distributes idle cores to scheduler proxies that need cores.
+        /// </summary>
+        void DistributeIdleCores(unsigned int totalCoresAvailable, unsigned int numReceivers);
+
+        /// <summary>
+        ///     Assigns a fixed number of unused or idle cores to a scheduler from a given node.
+        /// </summary>
+        void DynamicAssignCores(SchedulerProxy * pReceivingProxy, unsigned int nodeIndex, unsigned int numCoresToMigrate, bool fIdle);
+
+        /// <summary>
+        ///     Transfers a fixed number of cores from one scheduler to another.
+        /// </summary>
+        void DynamicMigrateCores(DynamicAllocationData * pGivingProxyData, SchedulerProxy * pReceivingProxy, unsigned int nodeIndex, unsigned int numCoresToMigrate);
+
+#if defined (CONCRT_TRACING)
+
+        /// <summary>
+        ///     Captures the initial state of the global map at the beginning of core migration, each cycle.
+        /// </summary>
+        void TraceInitialDRMState();
+
+        /// <summary>
+        ///     Captures data relating to an action during DRM preprocessing.
+        /// </summary>
+        void TracePreProcessingAction(SchedulerProxy * pProxy, unsigned int nodeIndex, unsigned int coreIndex,
+                                      bool fMarkedAsOwned, bool fBorrowedCoreRemoved, bool fSharedCoreRemoved, bool fIdleCore);
+
+        /// <summary>
+        ///     Captures data relating to an action during DRM core migration.
+        /// </summary>
+        void TraceCoreMigrationAction(SchedulerProxy * pGiver, SchedulerProxy * pReceiver, unsigned int round, unsigned int nodeIndex,
+                                      unsigned int coreIndex, bool fUnusedCoreMigration, bool fIdleCoreSharing, bool fBorrowedByGiver,
+                                      bool fIdleOnGiver);
+
+#endif
+        /// <summary>
+        ///     Performs borrowed core validation. A core can be borrowed by only one scheduler at a time.
+        /// </summary>
+        void ValidateBorrowedCores();
+
+        /// <summary>
+        ///     Performs state validations during dynamic core migration.
+        /// </summary>
+        void ValidateDRMSchedulerState();
+
+        /// <summary>
+        ///     Performs state validations during static allocation.
+        /// </summary>
+        void ValidateStaticSchedulerState(SchedulerProxy * pSchedulerProxy);
+
+        /// <summary>
+        ///     Main thread procedure for the dynamic RM worker thread.
+        /// </summary>
+        /// <param name="lpParameter">
+        ///     Resource manager pointer passed to the worker thread.
+        /// </param>
+        /// <returns>
+        ///     Status on thread exit.
+        /// </returns>
+        static DWORD CALLBACK DynamicRMThreadProc(LPVOID lpParameter);
+
+        /// <summary>
+        ///     Given a set of scaled floating point allocations that add up to nSum, rounds them to integers.
+        /// </summary>
+        static void RoundUpScaledAllocations(AllocationData ** ppData, unsigned int count, unsigned int nSum);
+    };
+
+    #pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ScheduleGroupBase.cpp

@@ -0,0 +1,870 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ScheduleGroupBase.cpp
+//
+// Implementation file for ScheduleGroupBase.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Constructs a schedule group with an initial reference count of 1.
+    /// </summary>
+    ScheduleGroupBase::ScheduleGroupBase(SchedulerBase *pScheduler, location* pGroupPlacement) :
+        m_pScheduler(pScheduler),
+        m_pAffineSegments(NULL),
+        m_pNonAffineSegments(NULL),
+        m_refCount(0)
+    {
+        Initialize(pGroupPlacement);
+        m_id = m_pScheduler->GetNewScheduleGroupId();
+    }
+
+    /// <summary>
+    ///     Performs initialization (or reinitialization) of a schedule group.
+    /// </summary>
+    void ScheduleGroupBase::Initialize(location* pGroupPlacement)
+    {
+        ASSERT(m_refCount == 0);
+        m_refCount = 1;
+        m_groupPlacement = *pGroupPlacement;
+
+        OMTRACE(MTRACE_EVT_INITIALIZED, this, NULL, NULL, 0);
+    }
+
+    /// <summary>
+    ///     Constructs a new schedule group segment with a specific affinity in the specified ring.
+    /// </summary>
+    /// <param name="pOwningGroup">
+    ///     The group to which this segment belongs.
+    /// </param>
+    /// <param name="pOwningRing">
+    ///     The ring in which this segment is contained.
+    /// </param>
+    /// <param name="pSegmentAffinity">
+    ///     The affinity of this segment.
+    /// </param>
+    ScheduleGroupSegmentBase::ScheduleGroupSegmentBase(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location* pSegmentAffinity) :
+        m_mailedTasks(pOwningGroup->GetScheduler(), pOwningGroup->GetScheduler()->GetBitSet(&m_affinity)),
+        m_workQueues(pOwningGroup->GetScheduler(), 256, 64),
+        m_detachedWorkQueues(pOwningGroup->GetScheduler(), 256, ListArray< ListArrayInlineLink<WorkQueue> >::DeletionThresholdInfinite), // No deletion
+        m_lastServiceTime(0)
+    {
+        Initialize(pOwningGroup, pOwningRing, pSegmentAffinity);
+    }
+
+    /// <summary>
+    ///     Initializes a schedule group segment.
+    /// </summary>
+    /// <param name="pOwningGroup">
+    ///     The group to which this segment belongs.
+    /// </param>
+    /// <param name="pOwningRing">
+    ///     The ring in which this segment is contained.
+    /// </param>
+    /// <param name="pSegmentAffinity">
+    ///     The affinity of this segment.
+    /// </param>
+    void ScheduleGroupSegmentBase::Initialize(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location *pSegmentAffinity)
+    {
+        m_pOwningGroup = pOwningGroup;
+        m_pRing = pOwningRing;
+        m_affinity = *pSegmentAffinity;
+        m_priorityServiceLink.m_type = BoostedObject::BoostTypeScheduleGroupSegment;
+        m_priorityServiceLink.m_boostState = BoostedObject::BoostStateUnboosted;
+
+        m_affinitySet = pOwningGroup->GetScheduler()->GetBitSet(pSegmentAffinity);
+        if (pSegmentAffinity->_GetType() == location::_ExecutionResource)
+        {
+            m_maskIdIf = pOwningGroup->GetScheduler()->GetResourceMaskId(pSegmentAffinity->_GetId());
+        }
+        m_mailedTasks.Initialize(m_affinitySet);
+    }
+
+    /// <summary>
+    ///     Creates a new segment with the specified affinity within the specified ring.
+    /// </summary>
+    /// <param name="pSegmentAffinity">
+    ///     The affinity of the segment.
+    /// </param>
+    /// <param name="pOwningRing">
+    ///     The ring into which the new segment will be placed.  Some aspect of pSegmentAffinity must overlap with the node to which this ring
+    ///     belongs.
+    /// </param>
+    /// <returns>
+    ///     A new segment with the specified affinity within the specified ring.
+    /// </returns>
+    ScheduleGroupSegmentBase *ScheduleGroupBase::CreateSegment(location* pSegmentAffinity, SchedulingRing *pOwningRing)
+    {
+        ScheduleGroupSegmentBase **pSegmentList = pSegmentAffinity->_Is_system() ? &m_pNonAffineSegments : &m_pAffineSegments;
+
+        //
+        // At the moment, there is no point in free listing segments -- they are bound to the lifetime of the group.  There should never be
+        // anything on the free list except at destruct time.
+        //
+        ScheduleGroupSegmentBase *pSegment = NULL;
+
+        if (pSegmentAffinity->_Is_system())
+        {
+            pSegment = pOwningRing->m_nonAffineSegments.PullFromFreePool();
+        }
+        else
+        {
+            pSegment = pOwningRing->m_affineSegments.PullFromFreePool();
+        }
+
+        if (pSegment == NULL)
+        {
+            pSegment = AllocateSegment(pOwningRing, pSegmentAffinity);
+        }
+        else
+        {
+            pSegment->Initialize(this, pOwningRing, pSegmentAffinity);
+        }
+
+        pSegment->m_pNext = *pSegmentList;
+        *pSegmentList = pSegment;
+
+        //
+        // If this ring is not active yet, make it active.  This would happen for a ring which we have no virtual processors / nodes in but which
+        // we've created a segment in.  We would do this if we knew a-priori that we were running on a thread / virtual processor affine to that node
+        // and scheduled work to this scheduler from there despite this scheduler not having any virtual processors from that node.  There are two ways
+        // in which this might happen:
+        //
+        // 1: We decide that location::current can return specific locations from an external thread.  Today this is not done.
+        // 2: We might be running on scheduler A / node X and schedule work to scheduler B from there.  We're on node X even though scheduler B doesn't
+        //    *currently* have any virtual processors there.
+        //
+        // In either of these cases, we'll still fork the group (create a new segment) within the node/ring even though we have no virtual processors there.
+        // After all, we never know when dynamic RM will kick in and change that.
+        //
+        // Note that this does *NOT* necessarily mean that the work is strongly affine to a non-existent node/ring!
+        //
+        if (!pOwningRing->IsActive())
+        {
+            pOwningRing->Activate();
+        }
+
+        if (pSegmentAffinity->_Is_system())
+        {
+            pOwningRing->m_nonAffineSegments.Add(pSegment);
+        }
+        else
+        {
+            pOwningRing->m_affineSegments.Add(pSegment);
+        }
+
+        OMTRACE(MTRACE_EVT_CREATESEGMENT, this, NULL, NULL, pSegment);
+
+        return pSegment;
+    }
+
+    /// <summary>
+    ///     Internal routine which finds an appropriate segment for a task placement.
+    /// </summary>
+    /// <param name="pSegmentAffinity">
+    ///     A segment with this affinity will be located.
+    /// </param>
+    /// <param name="pRing">
+    ///     A segment with pSegmentAffinity within this ring will be found.  A given location may be split into multiple segments by node in order
+    ///     to keep work local.
+    /// </param>
+    /// <returns>
+    ///     A segment with the specified affinity close to the specified location.
+    /// </returns>
+    ScheduleGroupSegmentBase *ScheduleGroupBase::FindSegment(location* pSegmentAffinity, SchedulingRing *pRing)
+    {
+        ScheduleGroupSegmentBase **pSegmentList = pSegmentAffinity->_Is_system() ? &m_pNonAffineSegments : &m_pAffineSegments;
+        ScheduleGroupSegmentBase *pSegment = *pSegmentList;
+
+        location origin = pRing->GetOwningNode()->GetLocation();
+
+        //
+        // @TODO:
+        //
+        // At some point, it might be beneficial to hash segments within the group instead of looking them up.  There will be M * N segments
+        // within a group where M is the number of different locations utilized and N is the number of nodes which those locations span.
+        //
+        while (pSegment != NULL)
+        {
+            if (pSegment->GetAffinity() == *pSegmentAffinity && pSegment->GetSchedulingRing() == pRing)
+            {
+                break;
+            }
+
+            pSegment = pSegment->m_pNext;
+        }
+
+        return pSegment;
+    }
+
+    /// <summary>
+    ///     Locates a segment that is appropriate for scheduling a task within the schedule group given information about the task's placement
+    ///     and the origin of the thread making the call.
+    /// </summary>
+    /// <param name="pSegmentAffinity">
+    ///     A segment with affinity to this particular location will be located.
+    /// </param>
+    /// <param name="pOrigin">
+    ///     A location representing the origin of the search.  The scheduler will tend to fork a given pSegmentAffinity into segments by node in order
+    ///     to keep locally scheduled work with the same affinity local.
+    /// </param>
+    /// <param name="fCreateNew">
+    ///     An indication as to whether the schedule group can create a new segment if an appropriate segment cannot be found.  If this parameter is
+    ///     specified as true, NULL will never be returned from this method; otherwise, it can be if no matching segment can be found.
+    /// </param>
+    /// <returns>
+    ///     A segment appropriate for scheduling work with affinity to pSegmentAffinity from code executing at pOrigin.  Note that NULL may be returned
+    ///     if fCreateNew is specified as false and no appropriate segment yet exists for the group.
+    /// </returns>
+    ScheduleGroupSegmentBase *ScheduleGroupBase::LocateSegment(location* pSegmentAffinity, bool fCreateNew)
+    {
+        //
+        // In general, we wish to find a segment local to our origin (the node where the current context is executing) that has a placement
+        // of pSegmentAffinity, or create a new segment should one not yet exist within the group.
+        //
+        // In practice, a segment will only be created specific to the current ring, if the current ring's affinity is "within" pSegmentAffinity.
+        // Otherwise, someone creating a group and saying something like:
+        //
+        // pGroup->ScheduleTask(..., N0);
+        //                     (..., N1);
+        //                     (..., N2);
+        //                     (..., Nn);
+        //
+        // might wind up creating n^2 segments within the group for no good reason.
+        //
+        // This will also allow unbiased work to fork per node and work on local portions.  This is exactly the kind of separation we want.
+        //
+        // Note that it is possible that we cannot place the current thread (or the scheduler chooses not to) and FindCurrentNode will return NULL.  It's also
+        // possible that the pSegmentAffinity to locate does not intersect our origin (even if the scheduler could place the current thread).  In either of these
+        // cases, we revert back to previous behavior and round robin an appropriate ring.  The ring's affinity must intersect pSegmentAffinity in some way!
+
+        //
+        SchedulingNode * pNode = m_pScheduler->FindCurrentNode();
+        SchedulingRing *pRing = (pNode != NULL) ? pNode->GetSchedulingRing() : m_pScheduler->GetNextSchedulingRing();
+
+        //
+        // Make sure pRing's affinity intersects pSegmentAffinity (or find a ring which does in round robin order).
+        //
+        location ringAffinity = pRing->GetOwningNode()->GetLocation();
+        location unbiased;
+        SchedulingRing * pFirstRing = pRing;
+
+        while (!ringAffinity._FastNodeIntersects(*pSegmentAffinity))
+        {
+            pRing = m_pScheduler->GetNextSchedulingRing(NULL, pRing);
+            ringAffinity = pRing->GetOwningNode()->GetLocation();
+
+            // If we've looped through all the SchedulingRings and haven't found an intersection, back off
+            // to an unbiased system-wide location.  This can occur on certain machines that have NUMA
+            // nodes with no processors, thus they have valid node locations with no ring created by the
+            // scheduler since they can do no work.
+            if (pRing == pFirstRing)
+            {
+                ASSERT(pSegmentAffinity->_GetType() == location::_NumaNode);
+                pSegmentAffinity = &unbiased;
+            }
+        }
+
+        //
+        // Do not hold a lock unless we need to create the segment.  This operation should be as inexpensive as possible in the majority case where
+        // the appropriate segment already exists.
+        //
+        ScheduleGroupSegmentBase *pSegment = FindSegment(pSegmentAffinity, pRing);
+        if (pSegment == NULL && fCreateNew)
+        {
+            m_segmentLock._Acquire();
+            pSegment = FindSegment(pSegmentAffinity, pRing);
+            if (pSegment == NULL)
+            {
+                pSegment = CreateSegment(pSegmentAffinity, pRing);
+            }
+            m_segmentLock._Release();
+        }
+
+        ASSERT(!pSegment || pSegment->GetSchedulingRing()->IsActive());
+        return pSegment;
+    }
+
+    /// <summary>
+    ///     Removes all schedule group segments from the group.
+    /// </summary>
+    void ScheduleGroupBase::RemoveSegments()
+    {
+        ScheduleGroupSegmentBase *pSegment = m_pNonAffineSegments;
+        ScheduleGroupSegmentBase *pNext = NULL;
+
+        while(pSegment)
+        {
+            pNext = pSegment->m_pNext;
+            pSegment->Remove();
+            pSegment = pNext;
+        }
+
+        pSegment = m_pAffineSegments;
+        while(pSegment)
+        {
+            pNext = pSegment->m_pNext;
+            pSegment->Remove();
+            pSegment = pNext;
+        }
+
+        m_pNonAffineSegments = NULL;
+        m_pAffineSegments = NULL;
+    }
+
+    /// <summary>
+    ///     Schedules a light-weight task within the schedule group.
+    /// </summary>
+    /// <param name="proc">
+    ///     A pointer to the function to execute to perform the body of the light-weight task.
+    /// </param>
+    /// <param name="data">
+    ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+    /// </param>
+    /// <remarks>
+    ///     Calling the <c>ScheduleTask</c> method implicitly places a reference count on the schedule group which is removed by the runtime
+    ///     at an appropriate time after the task executes.
+    /// </remarks>
+    /// <seealso cref="ScheduleGroup::Reference Method"/>
+    void ScheduleGroupBase::ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void* data)
+    {
+        ScheduleGroupSegmentBase *pSegment = LocateSegment(&m_groupPlacement, true);
+        pSegment->ScheduleTask(proc, data);
+    }
+
+    /// <summary>
+    ///     Schedules a light-weight task within the schedule group.  The light-weight task will also be biased towards executing at the specified location.
+    /// </summary>
+    /// <param name="proc">
+    ///     A pointer to the function to execute to perform the body of the light-weight task.
+    /// </param>
+    /// <param name="data">
+    ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+    /// </param>
+    /// <param name="placement">
+    ///     A reference to a location where the light-weight task will be biased towards executing at.
+    /// </param>
+    /// <remarks>
+    ///     Calling the <c>ScheduleTask</c> method implicitly places a reference count on the schedule group which is removed by the runtime
+    ///     at an appropriate time after the task executes.
+    /// </remarks>
+    /// <seealso cref="ScheduleGroup::Reference Method"/>
+    /// <seealso cref="location Class"/>
+    void ScheduleGroupBase::ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void * data, location& placement)
+    {
+        ScheduleGroupSegmentBase *pSegment = LocateSegment(&placement, true);
+        pSegment->ScheduleTask(proc, data);
+    }
+
+    /// <summary>
+    ///     Adds runnable context to the schedule group. This is usually a previously blocked context that
+    ///     was subsequently unblocked, but it could also be an internal context executing chores on behalf
+    ///     of an external context.
+    /// </summary>
+    void ScheduleGroupSegmentBase::AddRunnableContext(InternalContextBase* pContext, location bias)
+    {
+        ASSERT(pContext->GetScheduleGroupSegment() == this);
+        //
+        // If the current context does not belong to this group, the caller is not guaranteed to have a reference to the
+        // schedule group. We call CrossGroupRunnable() to make sure that scheduler and schedule group are kept around long
+        // enough, that we can attempt to startup the virtual processor without fear of the scheduler being finalized, or the
+        // schedule group being destroyed.
+        //
+        ContextBase* pCurrentContext = SchedulerBase::FastCurrentContext();
+
+        if ((pCurrentContext == NULL) || (pCurrentContext->GetScheduleGroupSegment() != this))
+        {
+            // Set this flag to allow the calling thread to use 'this' safely once the context is pushed onto runnables.
+            // Note that this call does not need a fence because it is fenced by push to the runnable contexts collection.
+            pContext->CrossGroupRunnable(TRUE);
+        }
+
+        //
+        // If there is an "inactive pending thread" virtual processor, this runnable should be shoved to it instead of going through the normal
+        // wake path.  There is *NO REASON* to require an SFW context to immediately switch to this.
+        //
+        SchedulerBase *pScheduler = m_pOwningGroup->GetScheduler();
+        if (!(pScheduler->HasVirtualProcessorPendingThreadCreate() && pScheduler->PushRunnableToInactive(pContext, bias)))
+        {
+            // Add it to the actual collection.
+            AddToRunnablesCollection(pContext);
+
+            if (!m_affinity._Is_system() && bias == m_affinity)
+            {
+                NotifyAffinitizedWork();
+            }
+
+            if (pScheduler->HasVirtualProcessorAvailable())
+            {
+                pScheduler->StartupIdleVirtualProcessor(this, bias);
+            }
+        }
+
+        // Reset the flag, if it was set, since we're done with touching scheduler/context data.
+        // This flag is not fenced. This means the reader could end up spinning a little longer until the data is
+        // propagated by the cache coherency mechanism.
+        pContext->CrossGroupRunnable(FALSE);
+        // NOTE: It is not safe to touch 'this' after this point, if this was a cross group runnable.
+    }
+
+    /// <summary>
+    ///     Steals an unrealized chore from a workqueue in the schedule group.
+    /// </summary>
+    /// <param name="fForceStealLocalized">
+    ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+    ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+    ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+    /// </param>
+    _UnrealizedChore* ScheduleGroupSegmentBase::StealUnrealizedChore(bool fForceStealLocalized)
+    {
+        //
+        // When we fail to steal from a work queue that's detached, it's an indication that the work queue
+        // is finally empty and can be retired.
+        //
+
+        _UnrealizedChore *pChore;
+
+        bool killEmptyQueues = false;
+        int maxIndex = m_workQueues.MaxIndex();
+        if (maxIndex > 0)
+        {
+            int skippedCount = 0;
+            const int maxSkippedCount = 16;
+            int skippedState[maxSkippedCount];
+            bool fEntered = false;
+
+            for (int j = 0; j < maxIndex; j++)
+            {
+                WorkQueue *pQueue = m_workQueues[j];
+                if (pQueue != NULL)
+                {
+                    if ( !pQueue->IsEmpty())
+                    {
+                        if ((pChore = pQueue->TryToSteal(fForceStealLocalized, fEntered)) != NULL)
+                            return pChore;
+                        else if ( !fEntered)
+                        {
+                            if (skippedCount < maxSkippedCount-1)
+                            {
+                                skippedState[skippedCount++] = j;
+                                continue;
+                            }
+                            else if ((pChore = pQueue->Steal(fForceStealLocalized)) != NULL)
+                                return pChore;
+                        }
+
+                        killEmptyQueues |= (pQueue->IsDetached() && pQueue->IsEmpty());
+                    }
+                    else
+                        killEmptyQueues |= pQueue->IsDetached();
+                }
+            }
+
+            if (skippedCount > 0)
+            {
+                for (int j = 0; j < skippedCount; j++)
+                {
+                    WorkQueue *pQueue = m_workQueues[skippedState[j]];
+                    if (pQueue != NULL)
+                    {
+                        if ( !pQueue->IsEmpty() && (pChore = pQueue->Steal(fForceStealLocalized)) != NULL)
+                            return pChore;
+                        else
+                            killEmptyQueues |= (pQueue->IsDetached() && pQueue->IsEmpty());
+                    }
+                }
+            }
+        }
+
+        if (m_mailedTasks.Dequeue(&pChore))
+        {
+            // The chore may not be from a detached workqueue, but since it is dequeued from a mailbox, we set it as detached
+            // which will add the stealing context to a list in the task collection instead of the owning contexts stealer collection.
+            pChore->_SetDetached(true);
+            return pChore;
+        }
+
+        int numDetachedArrays = m_detachedWorkQueues.MaxIndex();
+        if (numDetachedArrays > 0 && killEmptyQueues)
+        {
+            for (int i = 0; i < m_workQueues.MaxIndex(); i++)
+            {
+                WorkQueue *pQueue = m_workQueues[i];
+                if (pQueue != NULL)
+                {
+                    if (pQueue->IsDetached() && pQueue->IsUnstructuredEmpty())
+                    {
+                        SafelyDeleteDetachedWorkQueue(pQueue);
+                    }
+                }
+            }
+        }
+
+        return NULL;
+    }
+
+    /// <summary>
+    ///     Returns true if the group has any realized chores.
+    ///     This is used during scheduler finalization when only one thread is active in the scheduler.
+    ///     At any other time, this information is stale since new work could get added to the scheduler.
+    /// </summary>
+    bool ScheduleGroupSegmentBase::HasRealizedChores() const
+    {
+        return !m_realizedChores.Empty();
+    }
+
+    /// <summary>
+    ///     Returns the first work queue in the schedule group that has unrealized chores.
+    ///     This is only stable during scheduler finalization when only one thread is active in the scheduler.
+    ///     At any other time, this information is stale since new work could get added to the scheduler.
+    /// </summary>
+    WorkQueue *ScheduleGroupSegmentBase::LocateUnrealizedChores()
+    {
+        for (int i = 0; i < m_workQueues.MaxIndex(); i++)
+        {
+            WorkQueue *pQueue = m_workQueues[i];
+            if (pQueue != NULL)
+            {
+                if (!pQueue->IsStructuredEmpty() || !pQueue->IsUnstructuredEmpty())
+                {
+                    return pQueue;
+                }
+                else if (pQueue->IsDetached())
+                {
+                    SafelyDeleteDetachedWorkQueue(pQueue);
+                }
+            }
+        }
+
+        if (!m_mailedTasks.IsEmpty())
+            return MAILBOX_LOCATION;
+
+        return NULL;
+    }
+
+    /// <summary>
+    ///     Returns true if any of the workqueues in the schedule group has unrealized chores.
+    ///     This is only stable during scheduler finalization when only one thread is active in the scheduler.
+    ///     At any other time, this information is stale since new work could get added to the scheduler.
+    /// </summary>
+    bool ScheduleGroupSegmentBase::HasUnrealizedChores()
+    {
+        return LocateUnrealizedChores() != NULL;
+    }
+
+    /// <summary>
+    ///     Called to safely delete a detached work queue -- this is lock free and utilizes safe points to perform
+    ///     the deletion and dereference.  It can be called during the normal SFW or during the finalization sweep
+    ///     safely.
+    /// </summary>
+    bool ScheduleGroupSegmentBase::SafelyDeleteDetachedWorkQueue(WorkQueue *pQueue)
+    {
+        //
+        // The way in which we resolve race conditions between this and queue reattachment is by who is able to remove the
+        // element from the detached list array.  We cannot kill the work queue until it's gone out of that list array.
+        //
+        if (m_detachedWorkQueues.Remove(&pQueue->m_detachment, false))
+        {
+            //
+            // There's always the possibility of a very subtle race where we check IsDetached and IsUnstructuredEmpty and then
+            // are preempted, the queue is reattached, work is added, and it's detached again in the same spot with work.  We
+            // cannot free the queue in such circumstance.  Only if it is empty AFTER removal from m_detachedWorkQueues are
+            // we safe.
+            //
+            if (pQueue->IsUnstructuredEmpty())
+            {
+                //
+                // Each detached work queue holds a reference on the group.  It is referenced
+                // in ScheduleGroupBase::DetachActiveWorkQueue().  Since we are removing this
+                // empty work queue, we need to release the reference.
+                //
+                // There's an unfortunate reality here -- this work queue might be the LAST thing holding reference onto
+                // the schedule group.  It's entirely possible that someone just stole and hasn't yet gotten to the point
+                // where a reference is added to the schedule group.  If we arbitrarily release this reference, we might delete
+                // (or reuse) an active schedule group.  This could cause all sorts of problems.
+                //
+                // Instead of trying to release that reference here, we will wait until the next safe point to do so.  We
+                // are guaranteed no one is in the middle of stealing from this schedule group at that time.
+                //
+                // Note that this means that the stealer **MUST** stay within a critical region until after the WorkItem::TransferReferences
+                // call.
+                //
+                pQueue->RetireAtSafePoint(this);
+                return true;
+            }
+            else
+            {
+                CONCRT_COREASSERT(!m_pOwningGroup->GetScheduler()->InFinalizationSweep());
+
+                //
+                // The queue is not empty and we need to roll back.  Since we never removed the queue from m_workQueues, the work will
+                // still be found by the scheduler without undue futzing around sleep states.  The queue must, however, be placed
+                // back in m_detachedWorkQueues in a detached state.
+                //
+                // There's an unfortunate reality here too -- the slot used for the queue within the detached queues list might already
+                // be gone.  Adding back to the detached queues might trigger a heap allocation.  Given that this might be in SFW, a heap allocation
+                // triggering UMS would be bad.  Hence -- if we need to roll back (unlikely), we must do this at a safe point.
+                //
+                pQueue->RedetachFromScheduleGroupAtSafePoint(this);
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Creates a realized (non workstealing) chore in the schedule group. Used to schedule light-weight
+    ///     tasks and agents.
+    /// </summary>
+    void ScheduleGroupSegmentBase::ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void* data)
+    {
+        if (proc == NULL)
+        {
+            throw std::invalid_argument("proc");
+        }
+
+        SchedulerBase *pScheduler = m_pOwningGroup->GetScheduler();
+        RealizedChore *pChore = pScheduler->GetRealizedChore(proc, data);
+        TRACE(TRACE_SCHEDULER, L"ScheduleGroupBase::ScheduleTask(sgroup=%d,ring=0x%p,chore=0x%p)\n", Id(), m_pRing, pChore);
+
+        // Every task takes a reference on its schedule group. This is to ensure a schedule group has a ref count > 0 if
+        // no contexts are working on it, but queued tasks are present. The reference count is transferred to the context
+        // that eventually executes the task.
+        m_pOwningGroup->InternalReference();
+
+        m_realizedChores.Enqueue(pChore);
+
+        ContextBase *pCurrentContext = SchedulerBase::FastCurrentContext();
+
+        if (pCurrentContext == NULL || pCurrentContext->GetScheduler() != pScheduler)
+        {
+            //
+            // This is a thread that is in no way tracked in ConcRT (no context assigned to it) or it is a context foreign to
+            // this scheduler, so we cannot have statistics directly associated with its context. Instead, there is an entry in
+            // the TLS section PER scheduler that points to the external statistics mapping. From that information, we can know
+            // whether we have seen this thread before and whether it was ever scheduling tasks on the current scheduler.
+            //
+            ExternalStatistics * externalStatistics = (ExternalStatistics *) platform::__TlsGetValue(pScheduler->m_dwExternalStatisticsIndex);
+
+            if (externalStatistics == NULL)
+            {
+                //
+                // This is the first piece of statistical data for this thread on this scheduler, so
+                // create a statistics class, add it to the list array of statistics on this scheduler and
+                // save it in the TLS slot reserved for statistics on this scheduler.
+                //
+                externalStatistics = _concrt_new ExternalStatistics();
+                pScheduler->AddExternalStatistics(externalStatistics);
+                platform::__TlsSetValue(pScheduler->m_dwExternalStatisticsIndex, externalStatistics);
+            }
+            else
+            {
+                //
+                // We already have some statistical data for this thread on this scheduler.
+                //
+                ASSERT(pScheduler->m_externalThreadStatistics.MaxIndex() > 0);
+            }
+
+            ASSERT(externalStatistics != NULL);
+            externalStatistics->IncrementEnqueuedTaskCounter();
+        }
+        else if (pCurrentContext->IsExternal())
+        {
+            static_cast<ExternalContextBase *>(pCurrentContext)->IncrementEnqueuedTaskCounter();
+        }
+        else
+        {
+            static_cast<InternalContextBase *>(pCurrentContext)->IncrementEnqueuedTaskCounter();
+        }
+
+        //
+        // If there is explicit affinity placed on this new task, make sure to tell the scheduler so that it can send messages to any virtual
+        // processors as necessary to snap them back to affine work.
+        //
+        if (!m_affinity._Is_system())
+        {
+            NotifyAffinitizedWork();
+        }
+
+        // In most cases this if check will fail. To avoid the function call overhead in the common case, we check
+        // for virtual processors beforehand.
+        if (pScheduler->HasVirtualProcessorAvailableForNewWork())
+        {
+            pScheduler->StartupNewVirtualProcessor(this, m_affinity);
+        }
+
+    }
+
+
+    /// <summary>
+    ///     Places a work queue in the detached queue.  This will cause the work queue to remain eligible for stealing
+    ///     while the queue can be detached from a context.  The work queue will be recycled and handed back to a
+    ///     context executing within the schedule group that needs a queue.  If the queue is not recycled, it will be
+    ///     abandoned and freed when it becomes empty (a steal on it while in detached mode fails).
+    /// </summary>
+    void ScheduleGroupSegmentBase::DetachActiveWorkQueue(WorkQueue *pWorkQueue)
+    {
+        m_pOwningGroup->InternalReference();
+
+        //
+        // Note: there is a distinct lack of relative atomicity between the flag set and the queue add.  The worst thing that
+        //       happens here is that we ask the list array to remove an element at an invalid index.  It is prepared to handle
+        //       that anyway.
+        //
+        pWorkQueue->SetDetached(true);
+        m_detachedWorkQueues.Add(&pWorkQueue->m_detachment);
+    }
+
+    /// <summary>
+    ///     Called by a work queue in order to roll back an attempted kill that could not be committed due to reuse.
+    /// </summary>
+    void ScheduleGroupSegmentBase::RedetachQueue(WorkQueue *pWorkQueue)
+    {
+        //
+        // Roll back by reinserting into m_detachedWorkQueues.  We detect the error before setting detached state to false or releasing
+        // reference, so this is the only operation which needs to happen.  It just cannot happen during the steal due to the fact that
+        // there is a **SLIGHT** chance that the call will perform a heap allocation.
+        //
+        m_detachedWorkQueues.Add(&pWorkQueue->m_detachment);
+    }
+
+    /// <summary>
+    ///     Attempts to acquire a detached work queue from the schedule group.  If such a work queue is found, it
+    ///     is removed from detached queue and returned.  This allows recycling of work queues that are detached
+    ///     yet still have unstructured work.
+    ///</summary>
+    WorkQueue *ScheduleGroupSegmentBase::GetDetachedWorkQueue()
+    {
+        int maxIdx = m_detachedWorkQueues.MaxIndex();
+        for (int i = 0; i < maxIdx; i++)
+        {
+            ListArrayInlineLink<WorkQueue> *pLink = m_detachedWorkQueues[i];
+
+            //
+            // No code below this may dereference pLink unless it is removed from the list array.  There is no guarantee
+            // of safety as this can be called from an external context or multiple internal contexts.
+            //
+            if (pLink != NULL && m_detachedWorkQueues.Remove(pLink, i, false))
+            {
+                WorkQueue *pWorkQueue = pLink->m_pObject;
+
+                pWorkQueue->SetDetached(false);
+
+                //
+                // This removed detached work queue incremented the reference count
+                // in ScheduleGroupBase::DetachActiveWorkQueue().  Release it now.
+                //
+                // This is safe because we are inside the schedule group getting a work queue.  This means that there is already
+                // some context with a reference on the schedule group and it won't disappear out from underneath us by removing
+                // the detach reference.
+                //
+                m_pOwningGroup->InternalRelease();
+
+                return pWorkQueue;
+            }
+        }
+
+        return NULL;
+    }
+
+    /// <summary>
+    ///     Called by a work queue in order to retire itself at a safe point.
+    /// </summary>
+    void ScheduleGroupSegmentBase::RetireDetachedQueue(WorkQueue *pWorkQueue)
+    {
+        CONCRT_VERIFY(m_workQueues.Remove(pWorkQueue));
+
+        //
+        // This removed detached work queue incremented the reference count
+        // in ScheduleGroupBase::DetachActiveWorkQueue().  Release it now.
+        //
+        m_pOwningGroup->InternalRelease();
+    }
+
+    RealizedChore * ScheduleGroupSegmentBase::GetRealizedChore()
+    {
+        if (m_realizedChores.Empty())
+            return NULL;
+
+        RealizedChore *pChore = m_realizedChores.Dequeue();
+        TRACE(TRACE_SCHEDULER, L"ScheduleGroup::GetRealizedChore(sgroup=%d,ring=0x%p,chore=0x%p)\n", Id(), m_pRing, pChore);
+        return pChore;
+    }
+
+    /// <summary>
+    ///     Gets an internal context from either the idle pool or a newly allocated one and prepares it for
+    ///     execution. A NULL return value from the routine is considered fatal (out of memory). This is the
+    ///     API that should be used to obtain an internal context for execution. The context is associated
+    //      with this schedule group.
+    /// </summary>
+    InternalContextBase * ScheduleGroupSegmentBase::GetInternalContext(_Chore *pChore, bool choreStolen)
+    {
+        // Get an internal context from the idle pool
+        InternalContextBase* pContext = m_pOwningGroup->GetScheduler()->GetInternalContext();
+
+        if (pContext != NULL)
+        {
+            // Associate it with this schedule group
+            pContext->PrepareForUse(this, pChore, choreStolen);
+        }
+
+        return pContext;
+    }
+
+    /// <summary>
+    ///     Releases an internal context after execution into the idle pool. If the idle pool
+    ///     is full, it could be freed.
+    /// </summary>
+    void ScheduleGroupSegmentBase::ReleaseInternalContext(InternalContextBase *pContext)
+    {
+        pContext->RemoveFromUse();
+        m_pOwningGroup->GetScheduler()->ReleaseInternalContext(pContext);
+    }
+
+    /// <summary>
+    ///     Destroys a schedule group segment.
+    /// </summary>
+    ScheduleGroupSegmentBase::~ScheduleGroupSegmentBase()
+    {
+        //
+        // Make CERTAIN that the quick cache is cleared if this segment is contained within it.
+        //
+        if (m_affinity._GetType() == location::_ExecutionResource)
+        {
+            m_pOwningGroup->GetScheduler()->ClearQuickCacheSlotIf(m_maskIdIf, this);
+        }
+
+        // There shall be no work queues  (detached or otherwise) when a schedule group segment
+        // is deleted. This assumption is made in our safe point mechanism. If one
+        // of the workqueues in a schedule group segment requests a safe point invocation after
+        // the one for schedule group deletion, the workqueues would be deleted before
+        // its callback is invoked.
+        ASSERT(m_workQueues.IsEmptyAtSafePoint());
+        ASSERT(m_detachedWorkQueues.IsEmptyAtSafePoint());
+    }
+
+    /// <summary>
+    ///     Removes the segment.
+    /// </summary>
+    void ScheduleGroupSegmentBase::Remove()
+    {
+        OMTRACE(MTRACE_EVT_DESTROYSEGMENT, m_pOwningGroup, NULL, NULL, this);
+        // The order of operations here is important. Removing from the list array should be the last operation we perform on
+        // the segment.
+        m_pOwningGroup->m_pScheduler->RemovePrioritizedObject(&m_priorityServiceLink);
+        m_pRing->RemoveScheduleGroupSegment(this);
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ScheduleGroupBase.h

@@ -0,0 +1,654 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ScheduleGroupBase.h
+//
+// Header file containing ScheduleGroup related declarations.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+#define MAILBOX_LOCATION (reinterpret_cast<WorkQueue *>(1))
+
+namespace Concurrency
+{
+namespace details
+{
+    //
+    // A ScheduleGroupBase* object represents a schedule group as defined in the public API set.  It is a container of work which is related
+    // and benefits from temporally and spatially close scheduling.
+    //
+    // A ScheduleGroupSegmentBase* object represents a segment of a schedule group with affinity to a particular location -- in this case affinity
+    // to a particular scheduling node.
+    //
+
+    class ScheduleGroupBase;
+
+    /// <summary>
+    ///     A piece of a schedule group which is uniquely assigned to a given scheduling node/ring.
+    /// </summary>
+    class ScheduleGroupSegmentBase
+    {
+    public:
+
+        /// <summary>
+        ///     Called by a work queue in order to retire itself at a safe point.
+        /// </summary>
+        void RetireDetachedQueue(WorkQueue *pWorkQueue);
+
+        /// <summary>
+        ///     Called by a work queue in order to roll back an attempted kill that could not be committed due to reuse.
+        /// </summary>
+        void RedetachQueue(WorkQueue *pWorkQueue);
+
+        /// <summary>
+        ///     Destroys a schedule group segment.
+        /// </summary>
+        virtual ~ScheduleGroupSegmentBase();
+
+        /// <summary>
+        ///     Returns the group to which this segment belongs.
+        /// </summary>
+        ScheduleGroupBase *GetGroup() const
+        {
+            return m_pOwningGroup;
+        }
+
+        /// <summary>
+        ///     Returns the scheduling ring to which this segment belongs.
+        /// </summary>
+        SchedulingRing *GetSchedulingRing() const
+        {
+            return m_pRing;
+        }
+
+        /// <summary>
+        ///     Schedules a realized (non workstealing) chore in the schedule group segment.  Used to schedule light-weight
+        ///     tasks and agents.
+        /// </summary>
+        void ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void* data);
+
+        /// <summary>
+        ///     Marks the segment as serviced at a particular time mark.
+        /// </summary>
+        void ServiceMark(ULONGLONG markTime)
+        {
+            //
+            // Avoid cache contention on this by only writing the service time every so often.  We only care about this on granularities of something
+            // like 1/2 seconds anyway -- it's effectively the priority boost time granularity that we care about.
+            //
+            if (TimeSinceServicing(markTime) > 100)
+            {
+                OMTRACE(MTRACE_EVT_MARK, this, NULL, NULL, markTime);
+                m_lastServiceTime = markTime;
+            }
+        }
+
+        /// <summary>
+        ///    Returns the time delta between the last service time and the passed service time.
+        /// </summary>
+        ULONG TimeSinceServicing(ULONGLONG markTime)
+        {
+            return (ULONG) (markTime - m_lastServiceTime);
+        }
+
+        /// <summary>
+        ///     Returns a segment from its internal list entry.
+        /// </summary>
+        static ScheduleGroupSegmentBase* FromBoostEntry(BoostedObject *pEntry)
+        {
+            return CONTAINING_RECORD(pEntry, ScheduleGroupSegmentBase, m_priorityServiceLink);
+        }
+
+        /// <summary>
+        ///     Notifies virtual processors that work affinitized to them has become available in the schedule group segment.
+        /// </summary>
+        virtual void NotifyAffinitizedWork() =0;
+
+    protected:
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Constructs a new schedule group segment with a specific affinity in the specified ring.
+        /// </summary>
+        /// <param name="pOwningGroup">
+        ///     The group to which this segment belongs.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The ring in which this segment is contained.
+        /// </param>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity of this segment.
+        /// </param>
+        ScheduleGroupSegmentBase(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location* pSegmentAffinity);
+
+        /// <summary>
+        ///     Initializes a schedule group segment.
+        /// </summary>
+        /// <param name="pOwningGroup">
+        ///     The group to which this segment belongs.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The ring in which this segment is contained.
+        /// </param>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity of this segment.
+        /// </param>
+        void Initialize(ScheduleGroupBase *pOwningGroup, SchedulingRing *pOwningRing, location *pSegmentAffinity);
+
+        /// <summary>
+        ///     Adds runnable context to the schedule group. This is usually a previously blocked context that
+        ///     was subsequently unblocked, but it could also be an internal context executing chores on behalf
+        ///     of an external context.
+        /// </summary>
+        void AddRunnableContext(InternalContextBase *pContext, location bias = location());
+
+        /// <summary>
+        ///     Puts a runnable context into the runnables collection in the schedule group.
+        /// </summary>
+        virtual void AddToRunnablesCollection(InternalContextBase *pContext) =0;
+
+        virtual InternalContextBase *GetRunnableContext() = 0;
+
+        /// <summary>
+        ///     Returns true if the group has any realized chores.
+        ///     This is used during scheduler finalization when only one thread is active in the scheduler.
+        ///     At any other time, this information is stale since new work could get added to the scheduler.
+        /// </summary>
+        bool HasRealizedChores() const;
+
+        /// <summary>
+        ///     Returns the first work queue in the schedule group that has unrealized chores.
+        ///     This is only stable during scheduler finalization when only one thread is active in the scheduler.
+        ///     At any other time, this information is stale since new work could get added to the scheduler.
+        /// </summary>
+        /// <returns>
+        ///     This method either returns a special constant MAILBOX_LOCATION if work was found in the mailbox or
+        ///     a work queue in which an unrealized chore was found.
+        /// </returns>
+        WorkQueue *LocateUnrealizedChores();
+
+        /// <summary>
+        ///     Returns true if any of the workqueues in the schedule group has unrealized chores.
+        ///     This is only stable during scheduler finalization when only one thread is active in the scheduler.
+        ///     At any other time, this information is stale since new work could get added to the scheduler.
+        /// </summary>
+        bool HasUnrealizedChores();
+
+        /// <summary>
+        ///     Returns a realized chore if one exists in the queue.
+        /// </summary>
+        RealizedChore *GetRealizedChore();
+
+        /// <summary>
+        ///     Acquires an internal context for execution
+        /// </summary>
+        InternalContextBase* GetInternalContext(_Chore *pChore = NULL, bool choreStolen = false);
+
+        /// <summary>
+        ///     Releases an internal context after execution
+        /// </summary>
+        void ReleaseInternalContext(InternalContextBase *pContext);
+
+        /// <summary>
+        ///     Steals an unrealized chore from a workqueue in the schedule group.
+        /// </summary>
+        /// <param name="fForceStealLocalized">
+        ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+        ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+        ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+        /// </param>
+        _UnrealizedChore* StealUnrealizedChore(bool fForceStealLocalized = false);
+
+        /// <summary>
+        ///     Attempts to acquire a detached work queue from the schedule group.  If such a work queue is found, it
+        ///     is removed from detached queue and returned.  This allows recycling of work queues that are detached
+        ///     yet still have unstructured work.
+        ///</summary>
+        WorkQueue *GetDetachedWorkQueue();
+
+        /// <summary>
+        ///     Places a work queue in the detached queue.  This will cause the work queue to remain eligible for stealing
+        ///     while the queue can be detached from a context.  The work queue will be recycled and handed back to a
+        ///     context executing within the schedule group that needs
+        ///     a queue.  If the queue is not recycled, it will be abandoned and freed when it becomes empty (a steal on it
+        ///     while in detached mode fails).
+        /// </summary>
+        void DetachActiveWorkQueue(WorkQueue *pWorkQueue);
+
+        /// <summary>
+        ///     Called to safely delete a detached work queue -- this is lock free and utilizes safe points to perform
+        ///     the deletion and dereference.  It can be called during the normal SFW or during the finalization sweep
+        ///     safely.
+        /// </summary>
+        bool SafelyDeleteDetachedWorkQueue(WorkQueue *pQueue);
+
+        /// <summary>
+        ///     Returns a location representing the affinity of this segment.  Note that if the location returned is the system location,
+        ///     the segment has no specific placement affinity.  It may still have a weaker natural affinity to a particular node by
+        ///     nature of the fact that a segment is contained within a ring.
+        /// </summary>
+        const location& GetAffinity() const
+        {
+            return m_affinity;
+        }
+
+        /// <summary>
+        ///     Returns our cached affinity set.
+        /// </summary>
+        const QuickBitSet& GetAffinitySet() const
+        {
+            return m_affinitySet;
+        }
+
+        /// <summary>
+        ///     Removes the segment.
+        /// </summary>
+        void Remove();
+
+        //
+        // Private data
+        //
+
+        // Owning ring.
+        SchedulingRing *m_pRing;
+
+        // A location representing the affinity of this segment.
+        location m_affinity;
+
+        // The bitset representing m_affinity for quick masking.
+        QuickBitSet m_affinitySet;
+
+        // Quickly stashed maskId if the location for this segment is a core.
+        unsigned int m_maskIdIf;
+
+        // Each schedule group has three stores of work. It has a collection of runnable contexts (in the derived classes),
+        // a FIFO queue of realized chores and a list of workqueues that hold unrealized chores.
+
+        // A queue of realized chores.
+        SafeSQueue<RealizedChore, _HyperNonReentrantLock> m_realizedChores;
+
+        // The list of tasks which were mailed to this segment.
+        Mailbox<_UnrealizedChore> m_mailedTasks;
+
+        // A list array of all unrealized chore queues that are owned by contexts in this schedule group,
+        // protected by a r/w lock.
+        ListArray<WorkQueue> m_workQueues;
+
+        // A list array of work queues which still contain work within the schedule group but have become detached
+        // from their parent context (e.g.: a chore queues unstructured work and does not wait upon it before
+        // exiting).  This is the first level "free list".  Any context needing a work queue can grab one from
+        // here assuming it's executing the same schedule group.
+        ListArray< ListArrayInlineLink<WorkQueue> > m_detachedWorkQueues;
+
+        // The index that this schedule group is at in its containing ListArray
+        int m_listArrayIndex;
+
+        // Unique identifier
+        unsigned int m_id;
+
+        // The group to which this segment belongs
+        ScheduleGroupBase *m_pOwningGroup;
+
+        // The next segment within the group
+        ScheduleGroupSegmentBase * volatile m_pNext;
+
+        // The last time this segment was serviced.
+        ULONGLONG m_lastServiceTime;
+
+        //
+        // TRANSITION: This is a temporary patch on livelock until we can tie into priority for livelock prevention.
+        //
+        BoostedObject m_priorityServiceLink;
+
+    private:
+
+        friend class SchedulerBase;
+        friend class ScheduleGroupBase;
+        friend class ContextBase;
+        friend class ExternalContextBase;
+        friend class InternalContextBase;
+        friend class ThreadInternalContext;
+        friend class SchedulingNode;
+        friend class SchedulingRing;
+        friend class VirtualProcessor;
+        friend class WorkItem;
+        friend class WorkSearchContext;
+        template <class T> friend class ListArray;
+
+        // Intrusive links for list array.
+        SLIST_ENTRY m_listArrayFreeLink;
+    };
+
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class ScheduleGroupBase : public ScheduleGroup
+    {
+    public:
+        //
+        // Public Methods
+        //
+
+        /// <summary>
+        ///     Constructs a schedule group.
+        /// </summary>
+        ScheduleGroupBase(SchedulerBase *pScheduler, location* pGroupPlacement);
+
+        /// <summary>
+        ///     Virtual destructor
+        /// </summary>
+        virtual ~ScheduleGroupBase()
+        {
+        }
+
+        /// <summary>
+        ///     Performs initialization (or reinitialization) of a schedule group.
+        /// </summary>
+        void Initialize(location* pGroupPlacement);
+
+        /// <summary>
+        ///     Locates a segment that is appropriate for scheduling a task within the schedule group given information about the task's placement
+        ///     and the origin of the thread making the call.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     A segment with affinity to this particular location will be located.
+        /// </param>
+        /// <param name="fCreateNew">
+        ///     An indication as to whether the schedule group can create a new segment if an appropriate segment cannot be found.  If this parameter is
+        ///     specified as true, NULL will never be returned from this method; otherwise, it can be if no matching segment can be found.
+        /// </param>
+        /// <returns>
+        ///     A segment appropriate for scheduling work with affinity to segmentAffinity from code executing at origin.  Note that NULL may be returned
+        ///     if fCreateNew is specified as false and no appropriate segment yet exists for the group.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase *LocateSegment(location* pSegmentAffinity, bool fCreateNew);
+
+        /// <summary>
+        ///     Returns a pointer to the scheduler this group belongs to.
+        /// </summary>
+        SchedulerBase * GetScheduler() { return m_pScheduler; }
+
+        // ***************************************************************************
+        //
+        // Public Interface Derivations:
+        //
+
+        /// <summary>
+        ///     Returns a unique identifier to the schedule group.
+        /// </summary>
+        unsigned int Id() const
+        {
+            return m_id;
+        }
+
+        /// <summary>
+        ///     Increments the reference count of a schedule group.  A reference count is held for
+        ///       - every unstarted or incomplete realized chore that is part of the schedule group
+        ///       - every context that is executing a chore that was stolen from an unrealized chore queue
+        ///         within the schedule group
+        ///       - every external context attached to the scheduler instance, IFF this is the anonymous
+        ///         schedule group for the scheduler instance,
+        ///       - an external caller, IFF this schedule group was created using one of the public task
+        ///         creation APIs.
+        /// </summary>
+        /// <returns>
+        ///     Returns the resulting reference count.
+        /// </returns>
+        virtual unsigned int Reference()
+        {
+            return (unsigned int)InternalReference();
+        }
+
+        /// <summary>
+        ///     Decrements the reference count of a schedule group.  Used for composition.
+        /// </summary>
+        /// <returns>
+        ///     Returns the resulting reference count.
+        /// </returns>
+        virtual unsigned int Release()
+        {
+            return (unsigned int)InternalRelease();
+        }
+
+        /// <summary>
+        ///     Schedules a light-weight task within the schedule group.
+        /// </summary>
+        /// <param name="proc">
+        ///     A pointer to the function to execute to perform the body of the light-weight task.
+        /// </param>
+        /// <param name="data">
+        ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+        /// </param>
+        /// <remarks>
+        ///     Calling the <c>ScheduleTask</c> method implicitly places a reference count on the schedule group which is removed by the runtime
+        ///     at an appropriate time after the task executes.
+        /// </remarks>
+        /// <seealso cref="ScheduleGroup::Reference Method"/>
+        virtual void ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void* data);
+        //
+        // End of Public Interface Derivations:
+        //
+        // ***************************************************************************
+
+        /// <summary>
+        ///     Schedules a light-weight task within the schedule group.  The light-weight task will also be biased towards executing at the specified location.
+        /// </summary>
+        /// <param name="proc">
+        ///     A pointer to the function to execute to perform the body of the light-weight task.
+        /// </param>
+        /// <param name="data">
+        ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+        /// </param>
+        /// <param name="placement">
+        ///     A reference to a location where the light-weight task will be biased towards executing at.
+        /// </param>
+        /// <remarks>
+        ///     Calling the <c>ScheduleTask</c> method implicitly places a reference count on the schedule group which is removed by the runtime
+        ///     at an appropriate time after the task executes.
+        /// </remarks>
+        /// <seealso cref="ScheduleGroup::Reference Method"/>
+        /// <seealso cref="location Class"/>
+        void ScheduleTask(_In_ TaskProc proc, _Inout_opt_ void * data, location& placement);
+
+        /// <summary>
+        ///     Places a chore in a mailbox associated with the schedule group which is biased towards tasks being picked up from the specified
+        ///     location.
+        /// </summary>
+        /// <param name="pChore">
+        ///     The chore to mail.
+        /// </param>
+        /// <param name="pPlacement">
+        ///     A pointer to a location where the chore will be mailed.
+        /// </param>
+        /// <returns>
+        ///     The mailbox slot into which the chore was placed.
+        /// </returns>
+        /// <remarks>
+        ///     A mailed chore should also be placed on its regular work stealing queue.  The mailing must come first and once mailed, the chore body
+        ///     cannot be referenced until the slot is successfully claimed via a call to the ClaimSlot method.
+        /// </remarks>
+        virtual Mailbox<_UnrealizedChore>::Slot MailChore(_UnrealizedChore * pChore,
+                                                          location * pPlacement,
+                                                          ScheduleGroupSegmentBase ** ppDestinationSegment) =0;
+
+        /// <summary>
+        ///     Gets the first schedule group segment within the group that is either affine or non-affine as specified by fAffine.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetFirstScheduleGroupSegment(bool fAffine)
+        {
+            return fAffine ? m_pAffineSegments : m_pNonAffineSegments;
+        }
+
+        /// <summary>
+        ///     Gets the next schedule group segment within the group.  This will return only affine or non-affine segments depending
+        ///     on how GetFirstScheduleGroupSegment was called.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetNextScheduleGroupSegment(ScheduleGroupSegmentBase *pSegment)
+        {
+            return pSegment->m_pNext;
+        }
+
+    protected:
+        friend class ScheduleGroupSegmentBase;
+
+        friend class SchedulerBase;
+        friend class ContextBase;
+        friend class ExternalContextBase;
+        friend class InternalContextBase;
+        friend class ThreadInternalContext;
+        friend class SchedulingNode;
+        friend class SchedulingRing;
+        friend class VirtualProcessor;
+        friend class WorkItem;
+        friend class WorkSearchContext;
+        template <class T> friend class ListArray;
+
+        enum {
+            CacheLocalScheduling = 1,
+            FairScheduling = 2,
+            AnonymousScheduleGroup = 4
+        };
+
+        //
+        // Private data
+        //
+
+        // Owning scheduler
+        SchedulerBase *m_pScheduler;
+
+        // The lock which guards creation of segments.
+        _NonReentrantLock m_segmentLock;
+
+        // A linked list of explicitly affine segments within this group
+        ScheduleGroupSegmentBase *m_pAffineSegments;
+
+        // A linked list of segments which are not explicitly affine.
+        ScheduleGroupSegmentBase *m_pNonAffineSegments;
+
+        // Reference count for the schedule group
+        volatile long m_refCount;
+
+        // The index that this schedule group is at in its containing ListArray
+        int m_listArrayIndex;
+
+        // Unique identifier
+        unsigned int m_id;
+
+        // The location that the group schedules to by default.  A non-biased group will contain the system location.
+        location m_groupPlacement;
+
+        // flag indicating schedule group kind
+        BYTE m_kind;
+
+        //
+        // Private methods
+        //
+
+        /// <summary>
+        ///     Removes all schedule group segments from the group.
+        /// </summary>
+        virtual void RemoveSegments();
+
+        /// <summary>
+        ///     Non-virtual function that increments the reference count of a schedule group.
+        /// </summary>
+        LONG InternalReference()
+        {
+            if ((m_kind & AnonymousScheduleGroup) == 0)
+            {
+                ASSERT(m_refCount >= 0);
+                TRACE(TRACE_SCHEDULER, L"ScheduleGroupBase::InternalReference(rc=%d)\n", m_refCount+1);
+                LONG val = InterlockedIncrement(&m_refCount);
+
+                OMTRACE(MTRACE_EVT_REFERENCE, this, NULL, NULL, val);
+
+                return val;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        ///     Non-virtual function that decrements the reference count of a schedule group.
+        /// </summary>
+        LONG InternalRelease()
+        {
+            if ((m_kind & AnonymousScheduleGroup) == 0)
+            {
+                ASSERT(m_refCount > 0);
+                TRACE(TRACE_SCHEDULER, L"ScheduleGroupBase::InternalRelease(rc=%d)\n", m_refCount-1);
+                LONG newValue = InterlockedDecrement(&m_refCount);
+
+                OMTRACE(MTRACE_EVT_DEREFERENCE, this, NULL, NULL, newValue);
+
+                if (newValue == 0)
+                {
+                    RemoveSegments();
+                    m_pScheduler->RemoveScheduleGroup(this);
+                }
+                return newValue;
+            }
+            return 0;
+        }
+
+        bool IsFairScheduleGroup() const { return (m_kind & FairScheduling) != 0; }
+
+        /// <summary>
+        ///     Allocates a new cache local schedule group segment within the specified group and ring with the specified affinity.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity for the segment.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The scheduling ring to which the newly allocated segment will belong.
+        /// </param>
+        /// <returns>
+        ///     A new cache local schedule group within the specified group and ring with the specified affinity.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase* AllocateSegment(SchedulingRing *pOwningRing, location* pSegmentAffinity) = 0;
+
+        /// <summary>
+        ///     Creates a new segment with the specified affinity within the specified ring.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     The affinity of the segment.
+        /// </param>
+        /// <param name="pOwningRing">
+        ///     The ring into which the new segment will be placed.  Some aspect of segmentAffinity must overlap with the node to which this ring
+        ///     belongs.
+        /// </param>
+        /// <returns>
+        ///     A new segment with the specified affinity within the specified ring.
+        /// </returns>
+        ScheduleGroupSegmentBase *CreateSegment(location* pSegmentAffinity, SchedulingRing *pOwningRing);
+
+        /// <summary>
+        ///     Internal routine which finds an appropriate segment for a task placement.
+        /// </summary>
+        /// <param name="pSegmentAffinity">
+        ///     A segment with this affinity will be located.
+        /// </param>
+        /// <param name="pRing">
+        ///     A segment with segmentAffinity within this ring will be found.  A given location may be split into multiple segments by node in order
+        ///     to keep work local.
+        /// </param>
+        /// <returns>
+        ///     A segment with the specified affinity close to the specified location.
+        /// </returns>
+        virtual ScheduleGroupSegmentBase *FindSegment(location* pSegmentAffinity, SchedulingRing *pRing);
+
+    private:
+
+        // Intrusive links for list array.
+        SLIST_ENTRY m_listArrayFreeLink;
+    };
+#pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulerBase.h

@@ -0,0 +1,1691 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulerBase.h
+//
+// Header file containing the metaphor for a concrt scheduler
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+//
+// Defines how many (1 << x) pointers worth of padding there will be in between quick cache slots.
+//
+#ifdef _WIN64
+//
+// 64 bit:
+// 1 << 4 == 8 pointers * 8 == 64 bytes (assumed cache pad)
+//
+#define QUICKCACHEPAD_SHIFT 4
+#else // !_WIN64
+//
+// 32 bit:
+// 1 << 5 == 16 pointers * 4 == 64 bytes (assumed cache pad)
+//
+#define QUICKCACHEPAD_SHIFT 5
+#endif // _WIN64
+
+namespace Concurrency
+{
+namespace details
+{
+    // The base class that implements a scheduler instance
+
+    class SchedulerBase : public Scheduler
+    {
+    private:
+
+        //
+        // NESTED CLASSES:
+        //
+
+        /// <summary>
+        ///     Represents information about the NUMA nodes on the machine.
+        /// </summary>
+        struct NumaInformation
+        {
+            QuickBitSet m_nodeMask;
+            QuickBitSet m_resourceMask;
+        };
+
+        ///<summary>
+        ///     An intrusive node type for context tracking outside of the normal placement of contexts upon
+        ///     free/runnable lists.
+        ///</summary>
+        class ContextNode
+        {
+        public:
+
+            ContextNode(InternalContextBase *pContext) : m_pContext(pContext)
+            {
+            }
+
+            SLIST_ENTRY m_slNext{};
+            InternalContextBase *m_pContext;
+        };
+
+        ///<summary>
+        ///     A node that tracks events needing to be signaled at finalization time.
+        ///</summary>
+        class WaitNode
+        {
+        public:
+
+            WaitNode *m_pNext, *m_pPrev;
+            HANDLE m_hEvent;
+        };
+
+        ///<summary>
+        ///     A class that the scheduler uses to manage external context exit events for implicitly attached
+        ///     external contexts.
+        ///</summary>
+        class ContextExitEventHandler
+        {
+        public:
+
+            bool m_fCanceled;
+            // Count of handles the event handler is waiting on at any time.
+            unsigned short m_handleCount;
+            // Modified to reflect the new handle count after adding handles to the wait array and before notifying the
+            // watch dog of handle addition.
+            unsigned short m_newHandleCount;
+            // Event handle used to notify the event handler of certain events (new handle addition, shutdown).
+            HANDLE m_hWakeEventHandler;
+            SchedulerBase *m_pScheduler;
+            // prev, next pointers for the list of all handlers in the scheduler.
+            ContextExitEventHandler *m_pNext, *m_pPrev;
+            // list entry for a list of handlers with available slots for context handles. The scheduler uses this
+            // list when registering contexts.
+            ListEntry m_availableChain;
+            // The array of wait handles each thread waits on. Of these one is an event handle for notification
+            // and the rest are handles to OS contexts.
+            HANDLE m_waitHandleArray[MAXIMUM_WAIT_OBJECTS];
+        };
+
+    public:
+
+        /// <summary>
+        ///     Creates a scheduler that only manages internal contexts. Implicitly calls Reference.
+        ///     If Attach is called, the scheduler is no longer anonymous because it is also managing the external
+        ///     context where Attach was called.  To destroy an anonymous scheduler, Release needs to be called.
+        /// </summary>
+        /// <param name="policy">
+        ///     [in] A const reference to the scheduler policy.
+        /// </param>
+        /// <returns>
+        ///     A pointer to the new scheduler (never null)
+        /// </returns>
+        static _Ret_writes_(1) SchedulerBase* Create(_In_ const SchedulerPolicy& policy);
+        static _Ret_writes_(1) SchedulerBase* CreateWithoutInitializing(_In_ const SchedulerPolicy& policy);
+
+        // Constructor
+        SchedulerBase(_In_ const ::Concurrency::SchedulerPolicy& policy);
+
+        // dtor
+        virtual ~SchedulerBase();
+
+    public:  // Public Scheduler interface
+        /// <returns>
+        ///     Returns a unique identifier for this scheduler.  No error state.
+        /// </returns>
+        virtual unsigned int Id() const { return m_id; }
+
+        /// <returns>
+        ///     Returns a current number of virtual processors for this scheduler.  No error state.
+        /// </returns>
+        virtual unsigned int GetNumberOfVirtualProcessors() const { return m_virtualProcessorCount; };
+
+        /// <returns>
+        ///     Returns a copy of the policy this scheduler is using.  No error state.
+        /// </returns>
+        virtual SchedulerPolicy GetPolicy() const;
+
+        /// <summary>
+        ///     Increments a reference count to this scheduler to manage lifetimes over composition.</summary>
+        ///     This reference count is known as the scheduler reference count.
+        /// </summary>
+        /// <returns>
+        ///     The resulting reference count is returned.  No error state.
+        /// </returns>
+        virtual unsigned int Reference();
+
+        /// <summary>
+        ///     Decrements this scheduler's reference count to manage lifetimes over composition.
+        ///     A scheduler starts the shutdown protocol when the scheduler reference count goes to zero.
+        /// <summary>
+        /// <returns>
+        ///     The resulting reference count is returned.  No error state.
+        /// </returns>
+        virtual unsigned int Release();
+
+        /// <summary>
+        ///     Causes the OS event object 'event' to be set when the scheduler shuts down and destroys itself.
+        /// </summary>
+        /// <param name="event">
+        ///     [in] A handle to avalid event object
+        /// </param>
+        virtual void RegisterShutdownEvent(_In_ HANDLE event);
+
+        /// <summary>
+        ///     Attaches this scheduler to the calling thread. Implicitly calls Reference.
+        ///     After this function is called, the calling thread is then managed by the scheduler and the scheduler becomes the current scheduler.
+        ///     It is illegal for an internal context to call Attach on its current scheduler.
+        /// </summary>
+        virtual void Attach();
+
+        /// <summary>
+        ///     Allows a user defined policy to be used to create the default scheduler. It is only valid to call this API when no default
+        ///     scheduler exists. Once a default policy is set, it remains in effect until the next time the API is called (in the absence
+        ///     of a default scheduler).
+        /// </summary>
+        /// <param name="pPolicy">
+        ///     [in] A pointer to the policy to be set as the default. The runtime will make a copy of the policy
+        ///     for its use, and the user is responsible for the lifetime of the policy that is passed in.
+        /// </param>
+        static void SetDefaultSchedulerPolicy(_In_ const SchedulerPolicy & _Policy);
+
+        /// <summary>
+        ///     Resets the default scheduler policy, and the next time a default scheduler is created, it will use the runtime's default policy settings.
+        /// </summary>
+        static void ResetDefaultSchedulerPolicy();
+
+        /// <summary>
+        ///     Creates a new schedule group within the scheduler associated with the calling context.
+        /// </summary>
+        /// <returns>
+        ///     A pointer to the newly created schedule group.  This <c>ScheduleGroup</c> object has an initial reference count placed on it.
+        /// </returns>
+        /// <remarks>
+        ///     This method will result in the process' default scheduler being created and/or attached to the calling context if there is no
+        ///     scheduler currently associated with the calling context.
+        ///     <para>You must invoke the <see cref="ScheduleGroup::Release Method">Release</see> method on a schedule group when you are
+        ///     done scheduling work to it. The scheduler will destroy the schedule group when all work queued to it has completed.</para>
+        ///     <para>Note that if you explicitly created this scheduler, you must release all references to schedule groups within it, before
+        ///     you release your reference on the scheduler, via detaching the current context from it.</para>
+        /// </remarks>
+        /// <seealso cref="ScheduleGroup Class"/>
+        /// <seealso cref="ScheduleGroup::Release Method"/>
+        /// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+        virtual ScheduleGroup* CreateScheduleGroup()
+        {
+            location unbiased;
+            return InternalCreateScheduleGroup(&unbiased);
+        }
+
+        /// <summary>
+        ///     Creates a new schedule group within the scheduler associated with the calling context.  Tasks scheduled within the newly created
+        ///     schedule group will be biased towards executing at the specified location.
+        /// </summary>
+        /// <param name="_Placement">
+        ///     A reference to a location where the tasks within the schedule group will biased towards executing at.
+        /// </param>
+        /// <returns>
+        ///     A pointer to the newly created schedule group.  This <c>ScheduleGroup</c> object has an initial reference count placed on it.
+        /// </returns>
+        /// <remarks>
+        ///     This method will result in the process' default scheduler being created and/or attached to the calling context if there is no
+        ///     scheduler currently associated with the calling context.
+        ///     <para>You must invoke the <see cref="ScheduleGroup::Release Method">Release</see> method on a schedule group when you are
+        ///     done scheduling work to it. The scheduler will destroy the schedule group when all work queued to it has completed.</para>
+        ///     <para>Note that if you explicitly created this scheduler, you must release all references to schedule groups within it, before
+        ///     you release your reference on the scheduler, via detaching the current context from it.</para>
+        /// </remarks>
+        /// <seealso cref="ScheduleGroup Class"/>
+        /// <seealso cref="ScheduleGroup::Release Method"/>
+        /// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+        /// <seealso cref="location Class"/>
+        virtual ScheduleGroup * CreateScheduleGroup(location& _Placement)
+        {
+            return InternalCreateScheduleGroup(&_Placement);
+        }
+
+        /// <summary>
+        ///     Schedules a light-weight task within the scheduler.  The light-weight task will be placed in a schedule group of the runtime's choosing.
+        /// </summary>
+        /// <param name="proc">
+        ///     A pointer to the function to execute to perform the body of the light-weight task.
+        /// </param>
+        /// <param name="data">
+        ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+        /// </param>
+        /// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+        /// <seealso cref="ScheduleGroup Class"/>
+        virtual void ScheduleTask(TaskProc proc, void *data);
+
+        /// <summary>
+        ///     Schedules a light-weight task within the scheduler.  The light-weight task will be placed
+        ///     within a schedule group of the runtime's choosing.  It will also be biased towards executing at the specified location.
+        /// </summary>
+        /// <param name="proc">
+        ///     A pointer to the function to execute to perform the body of the light-weight task.
+        /// </param>
+        /// <param name="data">
+        ///     A void pointer to the data that will be passed as a parameter to the body of the task.
+        /// </param>
+        /// <param name="placement">
+        ///     A reference to a location where the light-weight task will be biased towards executing at.
+        /// </param>
+        /// <seealso cref="Task Scheduler (Concurrency Runtime)"/>
+        /// <seealso cref="ScheduleGroup Class"/>
+        /// <seealso cref="location Class"/>
+        virtual void ScheduleTask(TaskProc proc, void * data, location& placement);
+
+        /// <summary>
+        ///     Determines whether a given location is available on the scheduler.
+        /// </summary>
+        /// <param name="_Placement">
+        ///     A reference to the location to query the scheduler about.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether or not the location specified by the <paramref name="_Placement"/> argument is available on the scheduler.
+        /// </returns>
+        /// <remarks>
+        ///     Note that the return value is an instantaneous sampling of whether the given location is available.  In the presence of multiple
+        ///     schedulers, dynamic resource management may add or take away resources from schedulers at any point.  Should this happen, the given
+        ///     location may change availability.
+        /// </remarks>
+        virtual bool IsAvailableLocation(const location& _Placement) const;
+
+    public:  // Internal stuff
+
+        enum
+        {
+            //
+            // One shot starts with a single reference count placed implicitly by the module in which ConcRT is contained.
+            //
+            ONESHOT_NOT_INITIALIZED = 1,
+            ONESHOT_INITIALIZED_FLAG = 0x80000000
+        };
+
+        /// <summary>
+        ///     Returns whether or not the scheduler has performed one shot static construction.
+        /// </summary>
+        static bool IsOneShotInitialized() { return ((s_oneShotInitializationState & ONESHOT_INITIALIZED_FLAG) != 0); }
+
+        /// <summary>
+        ///     Detaches this scheduler from the current thread. It is required that the current scheduler on the thread be the same as 'this'
+        /// </summary>
+        void Detach();
+
+        /// <summary>
+        ///     Generates a unique identifier for a context.
+        /// </summary>
+        unsigned int GetNewContextId();
+
+        /// <summary>
+        ///     Generates a unique identifier for a schedule group.
+        /// </summary>
+        unsigned int GetNewScheduleGroupId();
+
+        /// <summary>
+        ///     Generates a unique identifier for a work queue across schedulers.
+        /// </summary>
+        static unsigned int GetNewWorkQueueId();
+
+        /// <summary>
+        ///     Gets a reserved context off the free list.  This is lock-free and safe to use at any point in the scheduler.  If a context
+        ///     is returned, it is a pre-bound and unstarted context.
+        /// </summary>
+        InternalContextBase *GetReservedContext()
+        {
+            return m_reservedContexts.Pop();
+        }
+
+        /// <summary>
+        ///     Releases the list of reserved contexts to the idle pool.  The thread proxy
+        ///     is released before returning the contexts to the idle pool.
+        /// </summary>
+        void ReleaseReservedContexts();
+
+        /// <summary>
+        ///     Acquires a new internal context of the appropriate type and returns it.  This can come from either
+        ///     a free list within the scheduler, or be one newly allocated from the heap.
+        /// </summary>
+        /// <param name="fThrottled">
+        ///     An indication as to whether the creation should be throttled.
+        /// </param>
+        InternalContextBase *GetInternalContext(bool fThrottled = true);
+
+        /// <summary>
+        ///     Acquires a new internal context of the appropriate type and notifies the scheduler when it is available.  The scheduler can
+        ///     choose what to do with said internal context.  This creation happens in a deferred manner subject to throttling constraints.
+        /// </summary>
+        void DeferredGetInternalContext();
+
+        ///<summary>
+        ///     Releases an internal context to the scheduler's idle pool.
+        ///</summary>
+        void ReleaseInternalContext(InternalContextBase *pContext, bool fUnbind = false);
+
+        /// <summary>
+        ///     Gets a realized chore from the idle pool, creating a new one if the idle pool is empty.
+        /// </summary>
+        RealizedChore *GetRealizedChore(TaskProc pFunction, void* pParameters);
+
+        ///<summary>
+        ///     Releases an external context of the to the scheduler's idle pool, destroying it if the idle pool is full.
+        ///</summary>
+        void ReleaseRealizedChore(RealizedChore *pChore);
+
+        /// <summary>
+        ///     References the anonymous schedule group, creating it if it doesn't exists, and returns a pointer to it.
+        /// </summary>
+        ScheduleGroupBase* GetAnonymousScheduleGroup()
+        {
+            return m_pAnonymousScheduleGroup;
+        }
+
+        /// <summary>
+        ///     References a segment in the anonymous schedule group and returns a pointer to it.
+        /// </summary>
+        /// <returns>
+        ///     A segment in the anonymous schedule group.
+        /// </returns>
+        ScheduleGroupSegmentBase *GetAnonymousScheduleGroupSegment();
+
+        static SchedulerBase* CurrentScheduler();
+        static SchedulerBase* FastCurrentScheduler();
+        static SchedulerBase* SafeFastCurrentScheduler();
+        static ContextBase* FastCurrentContext();
+        static ContextBase* SafeFastCurrentContext();
+        static ContextBase* CreateContextFromDefaultScheduler();
+        static ContextBase* CurrentContext()
+        {
+            if ( !IsOneShotInitialized())
+                return CreateContextFromDefaultScheduler();
+            ContextBase *pContext = (ContextBase*) platform::__TlsGetValue(t_dwContextIndex);
+            if (pContext == NULL)
+                return CreateContextFromDefaultScheduler();
+            return pContext;
+        }
+
+        /// <summary>
+        ///     Gets an IScheduler pointer for use in communication with the resource manager.
+        /// </summary>
+        virtual IScheduler* GetIScheduler() = 0;
+
+        /// <summary>
+        ///     Gets an IResourceManager pointer for use in communication with the resource manager.
+        /// </summary>
+        IResourceManager *GetResourceManager() const
+        {
+            return m_pResourceManager;
+        }
+
+        /// <summary>
+        ///     Gets an ISchedulerProxy pointer for use in communication with the resource manager.
+        /// </summary>
+        ISchedulerProxy *GetSchedulerProxy() const
+        {
+            return m_pSchedulerProxy;
+        }
+
+        /// <summary>
+        ///     Find an available virtual processor in the scheduler.
+        /// </summary>
+        bool FoundAvailableVirtualProcessor(VirtualProcessor::ClaimTicket& ticket,
+                                            location bias = location(),
+                                            ULONG type = VirtualProcessor::AvailabilityAny);
+
+        /// <summary>
+        ///     Try to steal from foreign nodes.
+        /// </summary>
+        InternalContextBase *StealForeignLocalRunnableContext(SchedulingNode *pSkipNode);
+
+        /// <summary>
+        ///     Start up a virtual processor in the scheduler, if one is found.  The virtual processor must have the specified availability
+        ///     characteristics.
+        /// </summary>
+        bool StartupVirtualProcessor(ScheduleGroupSegmentBase *pSegment,
+                                     location bias = location(),
+                                     ULONG type = VirtualProcessor::AvailabilityAny);
+
+        /// <summary>
+        ///     Start up an idle virtual processor in the scheduler.  This can be any virtual processor except one that is inactive due to
+        ///     waiting for a thread creation.
+        /// </summary>
+        bool StartupIdleVirtualProcessor(ScheduleGroupSegmentBase *pSegment, location bias = location())
+        {
+            //
+            // If the vproc is inactive pending thread -- there's no point in performing a general wake up.  The general wake up will require an SFW
+            // context which will simply put it back to sleep and violate our concurrency constraints.  Either an incoming runnable must push to the
+            // context or the throttler must wake it up.
+            //
+            return StartupVirtualProcessor(pSegment, bias, VirtualProcessor::AvailabilityAny & ~VirtualProcessor::AvailabilityInactivePendingThread);
+        }
+
+        /// <summary>
+        ///     Start up an new virtual processor in the scheduler. New virtual processor refers
+        ///     to any vproc that either has never been activated or has been deactivated due to lack
+        ///     of work (wait for work).
+        /// </summary>
+        virtual void StartupNewVirtualProcessor(ScheduleGroupSegmentBase *pSegment, location bias = location())
+        {
+            StartupVirtualProcessor(pSegment, bias, (VirtualProcessor::AvailabilityType)(VirtualProcessor::AvailabilityIdle | VirtualProcessor::AvailabilityInactive));
+        }
+
+        /// <summary>
+        ///     Attempts to push a runnable to an inactive virtual processor.  If successful, true is returned.
+        /// </summary>
+        virtual bool PushRunnableToInactive(InternalContextBase *pRunnableContext, location bias = location());
+
+        /// <summary>
+        ///     Called when a virtual processor becomes active (before it does) or becomes inactive (before it does).
+        /// </summary>
+        /// <param value="fActive">
+        ///     True if a virtual processor is going from INACTIVE to ACTIVE, and false if it is going from ACTIVE to INACTIVE.
+        /// </param>
+        /// <returns>
+        ///     For activation, the function returns true if the virtual processor was successfully activated, and false
+        ///     if it could not be activated because the scheduler was shutting down. For inactivation, it always returns true.
+        /// </returns>
+        bool VirtualProcessorActive(bool fActive);
+
+        /// <summary>
+        ///     Internal contexts and background threads call this when created and used inside the scheduler.
+        /// </summary>
+        void IncrementInternalContextCount();
+
+        /// <summary>
+        ///     Internal contexts and background threads call this function in order to notify that they are about to exit.
+        ///     The last caller will trigger scheduler finalization.
+        /// </summary>
+        void DecrementInternalContextCount();
+
+        /// <summary>
+        ///     Returns the scheduling protocol policy element value this scheduler was created with.
+        /// </summary>
+        ::Concurrency::SchedulingProtocolType GetSchedulingProtocol() { return m_schedulingProtocol; }
+
+        /// <summary>
+        ///     Returns a pointer to the 'next' scheduling ring in a round-robin manner
+        /// </summary>
+        SchedulingRing *GetNextSchedulingRing();
+
+        // Specifying pOwningNode produces an order of scheduling rings, ordered by node distance.
+        // pCurrentNode is the current position in said order.
+        SchedulingRing *GetNextSchedulingRing(const SchedulingRing *pOwningRing, SchedulingRing *pCurrentRing);
+
+        /// <summary>
+        ///     Sets the 'next' scheduling ring in a round-robin manner
+        /// </summary>
+        void SetNextSchedulingRing(SchedulingRing *pRing);
+
+        /// <summary>
+        ///     Returns true if the scheduler has gone past a certain point in PhaseTwoShutdown (when it sets the shutdown completed flag).
+        ///     This function is mainly used for debug asserts.
+        /// </summary>
+        bool HasCompletedShutdown();
+
+        /// <summary>
+        ///     Returns true if the scheduler is in the finalization sweep, i.e, the SUSPEND_GATE_FLAG is set.
+        ///     This function is mainly used for debug asserts.
+        /// </summary>
+        bool InFinalizationSweep();
+
+        /// <summary>
+        ///     Internal contexts call the scheduler when they go idle for a specified amount of time in order to allow
+        ///     things that happen on scheduler idle to happen (e.g.: sweeping for phase two shutdown).
+        ///     They must also call the scheduler when they transition out of idle before executing a work item or performing
+        ///     a context switch.  This may halt scheduler shutdown or it may coordinate with scheduler shutdown depending on
+        ///     the current phase of shutdown.
+        ///
+        ///     This call *MUST* be made from a scheduler critical region.
+        /// </summary>
+        /// <param name="fIdle">
+        ///     Specifies whether the processor is going idle or non-idle.
+        /// </param>
+        void VirtualProcessorIdle(bool fIdle);
+
+        /// <summary>
+        ///     Adds a new statistics class to track.
+        /// </summary>
+        /// <param name="pStats">
+        ///     The statistics we are adding to the scheduler's ListArray<ExternalStatistics> for tracking.
+        /// </param>
+        void AddExternalStatistics(ExternalStatistics * pStats)
+        {
+            m_externalThreadStatistics.Add(pStats);
+        }
+
+        /// <summary>
+        ///     Saves the statistical information from the retiring virtual processor.
+        /// </summary>
+        /// <param name="pVProc">
+        ///     The virtual processor that is retiring and whose statistics we are trying to preserve.
+        /// </param>
+        /// <remarks>
+        ///     The reason we use interlocked operation here is because multiple virtual processors can
+        ///     be retiring at the same time and the error can be much greater than on a simple increment.
+        /// </remarks>
+        void SaveRetiredVirtualProcessorStatistics(VirtualProcessor * pVProc)
+        {
+            InterlockedExchangeAdd((volatile long *) &m_enqueuedTaskCounter, pVProc->GetEnqueuedTaskCount());
+            InterlockedExchangeAdd((volatile long *) &m_dequeuedTaskCounter, pVProc->GetDequeuedTaskCount());
+        }
+
+        /// <summary>
+        ///     Resets the count of work coming in.
+        /// </summary>
+        /// <returns>
+        ///     Previous value of the counter.
+        /// </returns>
+        unsigned int GetEnqueuedTaskCount()
+        {
+            ULONG currentValue = m_enqueuedTaskCounter;
+            unsigned int retVal = (unsigned int) (currentValue - m_enqueuedTaskCheckpoint);
+
+            // Update the checkpoint value with the current value
+            m_enqueuedTaskCheckpoint = currentValue;
+
+            ASSERT(retVal < INT_MAX);
+            return retVal;
+        }
+
+        /// <summary>
+        ///     Resets the count of work being done.
+        /// </summary>
+        /// <returns>
+        ///     Previous value of the counter.
+        /// </returns>
+        unsigned int GetDequeuedTaskCount()
+        {
+            ULONG currentValue = m_dequeuedTaskCounter;
+            unsigned int retVal = (unsigned int) (currentValue - m_dequeuedTaskCheckpoint);
+
+            // Update the checkpoint value with the current value
+            m_dequeuedTaskCheckpoint = currentValue;
+
+            ASSERT(retVal < INT_MAX);
+            return retVal;
+        }
+
+        /// <summary>
+        ///     Returns a suballocator from the pool of suballocators in the process, or creates a new one. The RM only allows
+        ///     a fixed number of allocators for external contexts in the process, whereas every virtual processor that requests
+        ///     an allocator will get one.
+        /// </summary>
+        /// <param name="fExternalAllocator">
+        ///     Specifies whether the allocator is being requested for an external context. If this is 'true' the RM will return
+        ///     NULL if it has reached its limit of suballocators for external contexts. If this is 'false', the caller is requesting
+        ///     the suballocator for a virtual processor, and the RM *must* allocate one (resources permitting).
+        /// </param>
+        static SubAllocator* GetSubAllocator(bool fExternalAllocator);
+
+        /// <summary>
+        ///     Returns a suballocator back to the pool in the RM. The RM caches a fixed number of suballocators and will destroy the
+        ///     rest.
+        /// </summary>
+        static void ReturnSubAllocator(SubAllocator* pAllocator);
+
+        /// <summary>
+        ///     Enqueues a context into m_allContexts
+        /// </summary>
+        void AddContext(InternalContextBase * pContext);
+
+        /// <summary>
+        ///     Returns the first scheduling node.
+        /// </summary>
+        /// <param name="pIdx">
+        ///     The iterator position of the returned scheduling node will be placed here.  This can only be
+        ///     utilized as the pIdx parameter or the idxStart parameter of a GetNextSchedulingNode.
+        /// </param>
+        SchedulingNode *GetFirstSchedulingNode(int *pIdx)
+        {
+            *pIdx = 0;
+            return GetNextSchedulingNode(pIdx, -1);
+        }
+
+        /// <summary>
+        ///     Returns the next scheduling node in an iteration.
+        /// </summary>
+        SchedulingNode *GetNextSchedulingNode(int *pIdx, int idxStart = 0)
+        {
+            int base = *pIdx + (idxStart == -1 ? 0 : 1);
+            int size = m_nodeCount;
+            for (int i = 0; i < size; i++)
+            {
+                int index = (i + base) % size;
+                if (index == idxStart)
+                    return NULL;
+
+                SchedulingNode *pNode = m_nodes[index];
+                if (pNode != NULL)
+                {
+                    *pIdx = index;
+                    return pNode;
+                }
+            }
+
+            return NULL;
+        }
+
+        /// <summary>
+        ///     Performs a reference on one shot static items.  The caller should CheckOneShotStaticDestruction to remove
+        ///     the reference count.
+        /// </summary>
+        static LONG ReferenceStaticOneShot()
+        {
+            return InterlockedIncrement(&s_oneShotInitializationState);
+        }
+
+        /// <summary>
+        ///     Removes a previous reference on one shot static items.
+        /// </summary>
+        static LONG DereferenceStaticOneShot()
+        {
+            return InterlockedDecrement(&s_oneShotInitializationState);
+        }
+
+        /// <summary>
+        ///     Called at unload/process exit to perform cleanup of one-shot initialization items.
+        /// </summary>
+        static void CheckOneShotStaticDestruction();
+
+        /// <summary>
+        ///     Called when a particular virtual processor reaches a safe point.  This function does very little unless there has
+        ///     been a change in the version number of the safe point.
+        /// </summary>
+        /// <param name="pMarker">
+        ///     The safe point marker for a given virtual processor.  This is the virtual processor reaching a safe point.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a commit should take place.  If this is true, the caller should call CommitSafePoints when possible.
+        ///     Note that this is a return value so that things like UMS virtual processors can exit critical regions before performing
+        ///     the commit (to avoid, for instance, heap locks in critical regions).
+        /// </returns>
+        bool MarkSafePoint(SafePointMarker *pMarker);
+
+        /// <summary>
+        ///     Called to make a determination of what version of data we can commit up to.  This is the minimum data version that all virtual
+        ///     processors have observed.
+        /// </summary>
+        void CommitSafePoints();
+
+        /// <summary>
+        ///     The routine is used to trigger a safe point commit on all the vprocs by
+        ///     updating the data version.
+        /// </summary>
+        void TriggerCommitSafePoints(SafePointMarker *pMarker);
+
+        /// <summary>
+        ///     Determines how long in milliseconds until the next set of threads is allowed to be created.
+        /// </summary>
+        ULONG ThrottlingTime(ULONG stepWidth);
+
+        /// <summary>
+        ///     Returns the delay before the next thread can be created.
+        /// </summary>
+        ULONG ThrottlingDelta()
+        {
+            ULONGLONG curTime = platform::__GetTickCount64();
+            ULONG delta = (ULONG)(curTime - m_lastThrottledCreateTime);
+
+            return delta;
+        }
+
+        /// <summary>
+        ///     Puts a timestamp on the last time a throttled thread was created.
+        /// </summary>
+        void StampThrottledCreate()
+        {
+            m_lastThrottledCreateTime = platform::__GetTickCount64();
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is available.
+        /// </summary>
+        bool HasVirtualProcessorAvailable() const
+        {
+            return m_virtualProcessorAvailableCount > 0;
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is waiting for throttling.
+        /// </summary>
+        bool HasVirtualProcessorPendingThreadCreate() const
+        {
+            return m_virtualProcessorsPendingThreadCreate > 0;
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is available to execute new work.
+        /// </summary>
+        bool HasVirtualProcessorAvailableForNewWork() const
+        {
+            //
+            // The observational race (lack of atomicity between the two reads) should not matter.  If it does in some obscure
+            // case, a new atomic counter can be added.
+            //
+            return (m_virtualProcessorAvailableCount - m_virtualProcessorsPendingThreadCreate) > 0;
+        }
+
+        /// <summary>
+        ///     Removes an unreferenced schedule group from the scheduler's list of groups.
+        /// </summary>
+        void RemoveScheduleGroup(ScheduleGroupBase *pGroup);
+
+        /// <summary>
+        ///     Returns the scheduling node associated with the calling thread, if any. This method only returns a node if the current
+        ///     context is an internal context.
+        /// </summary>
+        SchedulingNode * FindCurrentNode();
+
+        /// <summary>
+        ///     Returns the scheduling node which pSrcLocation is a member of.  Note that if srcLocation and this node's location do not intersect,
+        ///     this will return NULL.
+        /// </summary>
+        SchedulingNode * FindNodeByLocation(location* pSrcLocation);
+
+        /// <summary>
+        ///     Returns whether or not a location has a tight binding to an object on this scheduler.
+        /// </summary>
+        bool IsLocationBound(const location* pLoc) const
+        {
+            return (pLoc->_GetBindingId() == m_id);
+        }
+
+        /// <summary>
+        ///     Returns a bit set for a given location to perform quick masking.
+        /// </summary>
+        QuickBitSet GetBitSet(const location* pLoc);
+
+        /// <summary>
+        ///     Notifies the scheduler that a given virtual processor is listening for affinity events pertaining to its underlying
+        ///     resource.  Note that this is a reference counted API.
+        /// </summary>
+        /// <param name="maskId">
+        ///     The mask id assigned for a given resource.
+        /// </param>
+        void ListenAffinity(unsigned int maskId)
+        {
+            m_nonAffineResourceListeners.InterlockedSet(maskId);
+            OMTRACE(MTRACE_EVT_LISTENINGTRUE, this, NULL, NULL, maskId);
+            ClearQuickCacheSlot(maskId);
+        }
+
+        /// <summary>
+        ///     Notifies the scheduler that a given virtual processor is ignoring messages for affinity events pertaining to its underlying
+        ///     resource.  Note that this is a reference counted API.
+        /// </summary>
+        /// <param name="maskId">
+        ///     The mask id assigned for a given resource.
+        /// </param>
+        void IgnoreAffinity(unsigned int maskId)
+        {
+            m_nonAffineResourceListeners.InterlockedClear(maskId);
+            OMTRACE(MTRACE_EVT_LISTENINGFALSE, this, NULL, NULL, maskId);
+        }
+
+        /// <summary>
+        ///     Called when affine work comes into the scheduler, this posts any required notifications to virtual processors which are executing
+        ///     non-affine work that they need to stop working on their current group and search for affine work again.
+        /// </summary>
+        void PostAffinityMessage(const QuickBitSet& srcMask)
+        {
+            if (srcMask.Intersects(m_nonAffineResourceListeners))
+            {
+                OMTRACE(MTRACE_EVT_POSTAFFINITYMESSAGE, this, NULL, NULL, srcMask.DbgAcquireBits(0));
+                m_affinityMessages.InterlockedSet(srcMask & m_nonAffineResourceListeners);
+            }
+        }
+
+        /// <summary>
+        ///     Returns whether a given resource id has a message for affinity and, if so, acknowledges it.
+        /// </summary>
+        bool AcknowledgedAffinityMessage(unsigned int maskId)
+        {
+            bool hasMessage = m_affinityMessages.IsSet(maskId);
+            if (hasMessage)
+                m_affinityMessages.InterlockedClear(maskId);
+
+            return hasMessage;
+        }
+
+        /// <summary>
+        ///     Returns the mask id for a given resource id.
+        /// </summary>
+        unsigned int GetResourceMaskId(unsigned int resourceId)
+        {
+            unsigned int val;
+            Hash<unsigned int, unsigned int>::ListNode *pNode = m_resourceBitMap.Find(resourceId, &val);
+            ASSERT(pNode != NULL);
+            return val;
+        }
+
+        /// <summary>
+        ///     Returns the number of mask ids associated with the scheduler.
+        /// </summary>
+        unsigned int GetMaskIdCount() const
+        {
+            return ::Concurrency::GetProcessorCount();
+        }
+
+        /// <summary>
+        ///     Acquires the quick cache slot.
+        /// </summary>
+        ScheduleGroupSegmentBase *AcquireQuickCacheSlot(unsigned int maskId)
+        {
+            //
+            // Make **SURE** this is short, sweet, and inlines.
+            //
+            if (m_pCoreAffinityQuickCache[static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT] > reinterpret_cast<ScheduleGroupSegmentBase *>(1))
+            {
+                return ActualGetQuickCacheSlot(maskId);
+            }
+
+            return NULL;
+        }
+
+        /// <summary>
+        ///     Clears the quick cache slot.
+        /// </summary>
+        void ClearQuickCacheSlot(unsigned int maskId)
+        {
+            if (m_pCoreAffinityQuickCache[static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT] == reinterpret_cast<ScheduleGroupSegmentBase *>(1))
+            {
+                InterlockedCompareExchangePointer(reinterpret_cast <void * volatile *>(m_pCoreAffinityQuickCache + (static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT)),
+                                                  reinterpret_cast <void *> (NULL),
+                                                  reinterpret_cast <void *> (1));
+            }
+        }
+
+        /// <summary>
+        ///     Clears a given quick cache slot if the slot contains a specific value.
+        /// </summary>
+        void ClearQuickCacheSlotIf(unsigned int maskId, ScheduleGroupSegmentBase *pSegment)
+        {
+            if (m_pCoreAffinityQuickCache[static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT] == pSegment)
+            {
+                InterlockedCompareExchangePointer(reinterpret_cast <void * volatile *>(m_pCoreAffinityQuickCache + (static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT)),
+                                                  reinterpret_cast <void *> (NULL),
+                                                  reinterpret_cast <void *> (pSegment));
+            }
+        }
+
+        /// <summary>
+        ///     Sets a given quick cache slot.  Each execution resource (by mask id) gets a quick cache slot.  When a work item arrives that is specifically
+        ///     affinitized to a given execution resource, the segment containing that work item is stashed in the quick cache slot for the corresponding
+        ///     execution resource.  This is a fast check which is made repeatedly during search-for-work.  This allows a virtual processor which is idle
+        ///     searching for work or which is executing non-affine work to quickly snap back to an affine segment without the need for a search.  This allows
+        ///     more rapid virtual processor spin-up for certain affinity scenarios.
+        /// </summary>
+        void SetQuickCacheSlot(unsigned int maskId, ScheduleGroupSegmentBase *pSegment)
+        {
+            if (m_pCoreAffinityQuickCache[static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT] == NULL)
+            {
+                InterlockedCompareExchangePointer(reinterpret_cast <void * volatile *>(m_pCoreAffinityQuickCache + (static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT)),
+                                                  reinterpret_cast <void *> (pSegment),
+                                                  reinterpret_cast <void *> (NULL));
+            }
+        }
+
+        /// <summary>
+        ///     Notifies the scheduler that a thread serving a virtual processor with the given mask id is actively searching for work.  This
+        ///     will prevent other virtual processors from picking up work which is affine to maskId but not affine to the other virtual processor.
+        /// </summary>
+        void NotifySearching(unsigned int maskId, bool fSearching)
+        {
+            if (fSearching)
+            {
+                m_idleSearch.InterlockedSet(maskId);
+                OMTRACE(MTRACE_EVT_SEARCHINGTRUE, this, NULL, NULL, maskId);
+                ClearQuickCacheSlot(maskId);
+            }
+            else
+            {
+                m_idleSearch.InterlockedClear(maskId);
+                OMTRACE(MTRACE_EVT_SEARCHINGFALSE, this, NULL, NULL, maskId);
+
+            }
+        }
+
+        /// <summary>
+        ///     Returns whether or not any of the set of virtual processors represented by bitSet is searching for work.
+        /// </summary>
+        bool HasSearchers(const QuickBitSet& bitSet) const
+        {
+            return m_idleSearch.Intersects(bitSet);
+        }
+
+        /// <summary>
+        ///     Checks whether a periodic scan is necessary, and if so, performs it.
+        /// </summary>
+        void PeriodicScan(ULONGLONG serviceTime)
+        {
+            //
+            // Right now, we only perform livelock service scan every 2 seconds.
+            //
+            if (serviceTime - m_lastServiceScan > 2000)
+                PerformServiceScan(serviceTime);
+        }
+
+        /// <summary>
+        ///     Increments the count of active resources by a given resource's mask id.
+        /// </summary>
+        void IncrementActiveResourcesByMask(unsigned int maskId)
+        {
+            m_activeSet.InterlockedSet(maskId);
+        }
+
+        /// <summary>
+        ///     Decrements the count of active resources by a given resource's mask id.
+        /// </summary>
+        void DecrementActiveResourcesByMask(unsigned int maskId)
+        {
+            m_activeSet.InterlockedClear(maskId);
+        }
+
+        //**************************************************
+        //
+        // TRANSITION: This is temporary until such time as we can hook into priority to solve livelock issues.
+        //
+
+        bool HasPriorityObjects() const
+        {
+            return !m_priorityObjects.Empty();
+        }
+
+        BoostedObject *GetNextPriorityObject();
+
+        void RemovePrioritizedObject(BoostedObject *pEntry);
+
+        //
+        // TRANSITION: End of temporary section
+        //
+        //**************************************************
+
+
+    protected:
+
+        SchedulerPolicy m_policy;
+
+        // scheduler policy fields
+        ::Concurrency::SchedulerType m_schedulerKind;
+        ::Concurrency::SchedulingProtocolType m_schedulingProtocol;
+        unsigned short m_localContextCacheSize;
+
+        // The total number of virtual processors in the scheduler, not including oversubscribed virtual processors.
+        // This number is adjusted as dynamic RM adds and removes cores.
+        volatile LONG m_virtualProcessorCount{};
+
+        // The default scheduler
+        static SchedulerBase* s_pDefaultScheduler;
+        static _StaticLock s_defaultSchedulerLock;
+
+        // The default scheduler policy
+        static SchedulerPolicy* s_pDefaultSchedulerPolicy;
+
+        // TLS data
+        static DWORD t_dwContextIndex;
+        DWORD m_dwExternalStatisticsIndex;
+
+        //
+        // NOTE:  Must cleanup up m_nodes before m_rings
+        //
+        NumaInformation* m_numaInformation{};
+        SchedulingNode** m_nodes{};
+        SchedulingRing** m_rings{};
+        int m_numaCount{};
+        int m_nodeCount{};
+
+        //
+        // The active set of virtual processors on this scheduler.
+        //
+        ReferenceCountedQuickBitSet m_activeSet;
+
+        //
+        // Tracking for virtual processors which need messages of notification for affine work scheduling, etc...
+        //
+        ReferenceCountedQuickBitSet m_idleSearch;
+        ReferenceCountedQuickBitSet m_nonAffineResourceListeners;
+        QuickBitSet m_affinityMessages;
+
+        //
+        // Quick cache for core affine tasks.
+        //
+        ScheduleGroupSegmentBase* volatile * m_pCoreAffinityQuickCache{};
+
+        // The list of schedule groups within the scheduler.  Note that while groups are owned by the scheduler, a group is merely
+        // a collection of segments where the individual segments are owned by scheduling rings.  This allows groups with affinity applied
+        // as well as separation of work within a group by which node scheduled it.
+        ListArray<ScheduleGroupBase> m_scheduleGroups;
+
+        // The single anonymous schedule group for the scheduler.  The anonymous schedule group will have one segment per ring.
+        ScheduleGroupBase *m_pAnonymousScheduleGroup{};
+
+        // Lock free list of all internal contexts in the scheduler
+        LockFreePushStack<ContextNode> m_allContexts;
+
+        SafeRWList<WaitNode> m_finalEvents;
+
+        // A list array that keeps statistical information for all non-internal contexts
+        ListArray<ExternalStatistics> m_externalThreadStatistics;
+
+        // Lock that guards the data structures for tracking context exit events.
+        _NonReentrantBlockingLock m_listArrayDeletionLock;
+
+        /// <summary>
+        ///     Activate the given virtual processor
+        /// </summary>
+        void ActivateVirtualProcessor(VirtualProcessor *pVirtualProcessor, ScheduleGroupBase *pGroup);
+
+        /// <summary>
+        ///     Returns a newly constructed internal context appropriate to the given type of scheduler.
+        /// </summary>
+        virtual InternalContextBase *CreateInternalContext() =0;
+
+        /// <summary>
+        ///     Increments the reference counts required by a scheduler attach.
+        /// </summary>
+        void ReferenceForAttach();
+
+        /// <summary>
+        ///     Decrements the reference counts incremented for scheduler attach.
+        /// </summary>
+        void ReleaseForDetach();
+
+        /// <summary>
+        ///     Returns a current number of active virtual processors for this scheduler
+        /// </summary>
+        /// <returns>
+        ///     Returns a current number of active virtual processors for this scheduler.  No error state.
+        /// </returns>
+        unsigned int GetNumberOfActiveVirtualProcessors() const { return m_activeVProcCount; };
+
+        ///<summary>
+        ///     Notification after a virtual processor goes from INACTIVE to ACTIVE or ACTIVE to INACTIVE
+        ///</summary>
+        /// <param value="fActive">
+        ///     True if a virtual processor is going from INACTIVE to ACTIVE, and false if it is going from ACTIVE to INACTIVE.
+        /// </param>
+        /// <param value="activeCount">
+        ///     Active virtual processor count after the transition
+        /// </param>
+        virtual void VirtualProcessorActiveNotification(bool fActive, LONG activeCount)
+        {
+            (fActive); (activeCount);
+        }
+
+        /// <summary>
+        ///     Indicates the type of work which exists within the scheduler.
+        /// </summary>
+        enum PendingWorkType
+        {
+            /// <summary>
+            ///     No work exists within the scheduler.
+            /// </summary>
+            NoWork,
+
+            /// <summary>
+            ///     There is user work within the scheduler (chores, tasks, blocked contexts, etc...).  There may or may not
+            ///     be ancillary work.
+            /// </summary>
+            UserWork,
+
+            /// <summary>
+            ///     There is ancillary work related to the scheduler (e.g.: queued timers for throttling, etc...)
+            /// </summary>
+            OnlyAncillaryWork
+        };
+
+        /// <summary>
+        ///     Determines if there is pending work such as blocked context/unstarted chores etc in the
+        ///     scheduler. If there is no pending work, the scheduler will attempt to shutdown.
+        /// </summary>
+        virtual PendingWorkType TypeOfWorkPending();
+
+        /// <summary>
+        ///     Initialize scheduler event handlers/background threads
+        /// </summary>
+        virtual void InitializeSchedulerEventHandlers();
+
+        /// <summary>
+        ///     Destroy scheduler event handlers/background threads
+        /// </summary>
+        virtual void DestroySchedulerEventHandlers();
+
+        /// <summary>
+        ///     Cancel all the internal contexts.
+        /// </summary>
+        virtual void CancelAllContexts();
+
+        /// <summary>
+        ///     Returns the count of bound contexts on the scheduler.
+        /// </summary>
+        ULONG GetNumberOfBoundContexts() const
+        {
+            return (ULONG)m_boundContextCount;
+        }
+
+        // Implementation for IScheduler interface APIs that is shared between to all derived classes.
+
+        /// <summary>
+        ///     Called by the resource manager in order to gather statistics for a given scheduler.  The statistics gathered here
+        ///     will be used to drive dynamic feedback with the scheduler to determine when it is appropriate to assign more resources
+        ///     or take resources away.  Note that these counts can be optimistic and do not necessarily have to reflect the current
+        ///     count with 100% synchronized accuracy.
+        /// </summary>
+        /// <param name="pTaskCompletionRate">
+        ///     The number of tasks which have been completed by the scheduler since the last call to the Statistics method.
+        /// </param>
+        /// <param name="pTaskArrivalRate">
+        ///     The number of tasks that have arrived in the scheduler since the last call to the Statistics method.
+        /// </param>
+        /// <param name="pNumberOfTasksEnqueued">
+        ///     The total number of tasks in all scheduler queues.
+        /// </param>
+        void Statistics(unsigned int *pTaskCompletionRate, unsigned int *pTaskArrivalRate, unsigned int *pNumberOfTasksEnqueued);
+
+        /// <summary>
+        ///     Called when the resource manager is giving virtual processors to a particular scheduler.  The virtual processors are
+        ///     identified by an array of IVirtualProcessorRoot interfaces. This call is made to grant virtual processor roots
+        ///     at initial allocation during the course of ISchedulerProxy::RequestInitialVirtualProcessors, and during dynamic
+        ///     core migration.
+        /// </summary>
+        /// <param name="pVirtualProcessorRoots">
+        ///     An array of IVirtualProcessorRoot interfaces representing the virtual processors being added to the scheduler.
+        /// </param>
+        /// <param name="count">
+        ///     Number of IVirtualProcessorRoot interfaces in the array.
+        /// </param>
+        void AddVirtualProcessors(IVirtualProcessorRoot **ppVirtualProcessorRoots, unsigned int count);
+
+        /// <summary>
+        ///     Called when the resource manager is taking away virtual processors from a particular scheduler.  The scheduler should
+        ///     mark the supplied virtual processors such that they are removed asynchronously and return immediately.  Note that
+        ///     the scheduler should make every attempt to remove the virtual processors as quickly as possible as the resource manager
+        ///     will reaffinitize threads executing upon them to other resources.  Delaying stopping the virtual processors may result
+        ///     in unintentional oversubscription within the scheduler.
+        /// </summary>
+        /// <param name="pVirtualProcessorRoots">
+        ///     An array of IVirtualProcessorRoot interfaces representing the virtual processors which are to be removed.
+        /// </param>
+        /// <param name="count">
+        ///     Number of IVirtualProcessorRoot interfaces in the array.
+        /// </param>
+        void RemoveVirtualProcessors(IVirtualProcessorRoot **ppVirtualProcessorRoots, unsigned int count);
+
+        /// <summary>
+        ///     Invoked when the Gate Count goes to zero as a result of virtual processor state transitions, while the
+        ///     scheduler has been marked for shutdown. It proceeds to sweep the scheduler if it can set the suspend flag
+        ///     on the shutdown gate while the gate count is still 0 and the scheduler is marked for shutdown.
+        /// </summary>
+        void AttemptSchedulerSweep();
+
+        /// <summary>
+        ///     Returns whether the reserved context pool can be utilized to fetch contexts to bypass throttling.
+        /// </summary>
+        virtual bool AllowGeneralFetchOfReservedContexts()
+        {
+            return true;
+        }
+
+    private:
+
+        friend class ContextBase;
+        friend class ::Concurrency::CurrentScheduler;
+        friend class ScheduleGroupBase;
+        friend class ScheduleGroupSegmentBase;
+        friend class FairScheduleGroup;
+        friend class CacheLocalScheduleGroup;
+        friend class InternalContextBase;
+        friend class ExternalContextBase;
+        friend class VirtualProcessor;
+        friend class SchedulingRing;
+        friend class SchedulingNode;
+        friend class SafePointInvocation;
+
+        //
+        // TRANSITION: This is a temporary patch for livelock prevention until we can hook into priority.
+        // TRANSITION: This **MUST** have a hyper lock on it.
+        //
+        SafeRWList<BoostedObject, CollectionTypes::NoCount, _ReaderWriterLock> m_priorityObjects;
+
+        // The list of invocations for safe point registrations.
+        SafeSQueue<SafePointInvocation, _HyperNonReentrantLock> m_safePointInvocations;
+
+        // Counter used to assign unique identifiers to contexts.
+        volatile LONG m_contextIdCounter;
+
+        // Counter used to assign unique identifiers to schedule groups.
+        volatile LONG m_scheduleGroupIdCounter;
+
+        // Counter used to assign unique identifiers to work queues.
+        static volatile LONG s_workQueueIdCounter;
+
+        // The current safe point version for data.  This indicates the newest data requiring observation by all virtual processors
+        volatile ULONG m_safePointDataVersion;
+
+        // The current safe point commit version.  This indicates the newest data that has been observed by all virtual processors
+        volatile ULONG m_safePointCommitVersion;
+
+        // The pending version that is being committed by one of the vprocs.
+        volatile ULONG m_safePointPendingVersion;
+
+        // Hash tables for conversion
+        Hash<unsigned int, unsigned int> m_resourceNodeMap;
+        Hash<unsigned int, unsigned int> m_resourceBitMap;
+
+        // scheduler id
+        unsigned int m_id;
+
+        // Round-robin index for scheduling ring.
+        unsigned int m_nextSchedulingRingIndex;
+
+        // Handle to a semaphore used to synchronize during scheduler finalization.
+        HANDLE m_hSchedulerShutdownSync{};
+
+        //
+        // Reference counts:
+        //
+        // m_refCount -- The externally visible reference count on the scheduler.  Incremented for attachment
+        //               and for explicit calls to Reference.  When this reference count falls to zero, the
+        //               scheduler initiates shutdown.  When m_internalContextCount falls to zero, the
+        //               scheduler finalizes.
+        //
+        // m_attachCount -- The count of external contexts to which this scheduler is attached.  This is primarily
+        //                  present for debugging purposes.
+        //
+        // m_internalContextCountPlusOne -- The count of internal contexts on the scheduler plus one.  Note that
+        //                                  it's +1 to explicitly handle any possibility of scheduler shutdown
+        //                                  before internal contexts are created.
+        //
+        // m_boundContextCount -- The count of internal contexts which are currently bound.  This affects how the scheduler
+        //                        throttles thread creation.
+        //
+        volatile LONG m_refCount;
+        volatile LONG m_attachCount;
+        volatile LONG m_internalContextCountPlusOne;
+        volatile LONG m_initialReference;
+        volatile LONG m_boundContextCount;
+
+        //
+        // The virtual processor shutdown gate.  This is used to implement scheduler shutdown, by ensuring a handshake
+        // when all virtual processors go idle.  When such happens, no virtual processor may go active again without
+        // handshaking.  During the period between handshakes, the scheduler is free to sweep schedule groups
+        // to detect whether finalization is yet appropriate.
+        //
+        // Layout:
+        //    31 - SHUTDOWN_INITIATED_FLAG   -- indicates that the external reference count on the scheduler has fallen to zero,
+        //                                      and the scheduler should be able to finalize when all work queued to it has
+        //                                      completed. This flag may be reset at a later point if an internal context
+        //                                      ends up resurrecting the scheduler.
+        //    30 - SUSPEND_GATE_FLAG         -- indicates a suspend phase while the scheduler is trying to evaluate whether
+        //                                      it is ready to finalize. A scheduler may find blocked contexts during this
+        //                                      phase and back off from finalization, resetting the flag. No contexts are allowed
+        //                                      to execute work during this phase, and no new virtual processors may be added
+        //                                      to the scheduler while this bit is set.
+        //    29 - SHUTDOWN_COMPLETED_FLAG   -- indicates that the scheduler has completed shutdown. This is the point of no
+        //                                      return, for this scheduler. At this point no work should exist in the scheduler,
+        //                                      and attempts to add any new virtual processors will fail, since the scheduler
+        //                                      is about to be destroyed.
+        //
+        volatile LONG m_vprocShutdownGate;
+
+        // An indication of whether we have done a sweep without actual work.
+        volatile LONG m_fSweepWithoutActualWork;
+
+        // An indication of how long it has been since the last sweep for livelocked segments.
+        volatile ULONGLONG m_lastServiceScan;
+
+        static _StaticLock s_schedulerLock;
+        static LONG s_initializedCount;
+
+        //
+        // The one shot initialization state has two parts, a reference count occupying the lower 31 bits and a flag indicating whether
+        // one shot initialization was performed in the top bit.
+        //
+        static LONG s_oneShotInitializationState;
+
+        IResourceManager *m_pResourceManager;
+        ISchedulerProxy *m_pSchedulerProxy{};
+
+        // The count of virtual processors active in the scheduler.
+        volatile LONG m_activeVProcCount;
+
+        // The number of virtual processors available to schedule more work.
+        // This does *NOT* take into account those virtual processors which are *inactive pending thread*
+        volatile LONG m_virtualProcessorAvailableCount{};
+
+        // The number of virtual processors available pending a thread creation.
+        volatile LONG m_virtualProcessorsPendingThreadCreate;
+
+        // Statistics data counters
+        volatile ULONG m_enqueuedTaskCounter;
+        volatile ULONG m_dequeuedTaskCounter;
+
+        // Statistics data checkpoints
+        ULONG m_enqueuedTaskCheckpoint;
+        ULONG m_dequeuedTaskCheckpoint;
+
+        //
+        // Throttling information:
+        //
+        ULONG m_threadsBeforeThrottling;
+        ULONGLONG m_lastThrottledCreateTime;
+
+        HANDLE m_hThrottlingTimer;
+        volatile LONG m_pendingDeferredCreates;
+
+        // Free list of internal contexts.
+        LockFreeStack<InternalContextBase> m_internalContextPool;
+
+        // Free list of external contexts.
+        LockFreeStack<ExternalContextBase> m_externalContextPool;
+
+        // Free list of realized chores.
+        LockFreeStack<RealizedChore> m_realizedChorePool;
+
+        // List of reserved contexts
+        LockFreeStack<InternalContextBase> m_reservedContexts;
+
+        // A stack that holds free suballocators.
+        static LockFreeStack<SubAllocator> s_subAllocatorFreePool;
+
+        // Number of suballocators for use by external contexts that are active in the process.
+        static volatile LONG s_numExternalAllocators;
+
+        // The max number of external contexts that could have suballocators at any given time.
+        static const int s_maxExternalAllocators;
+
+        // The maximum depth of the free pool of allocators.
+        static const int s_allocatorFreePoolLimit;
+
+        static void CheckStaticConstruction();
+        static void StaticConstruction();
+        static void StaticDestruction();
+        static void OneShotStaticConstruction();
+        static void OneShotStaticDestruction();
+
+        void Initialize();
+        void Cleanup();
+
+        int GetValidSchedulingRingIndex(int idx);
+        int GetNextValidSchedulingRingIndex(int idx);
+
+        /// <summary>
+        ///     Creates the correct type of virtual processor.
+        /// </summary>
+        virtual VirtualProcessor *CreateVirtualProcessor(SchedulingNode *pOwningNode, IVirtualProcessorRoot *pOwningRoot) = 0;
+
+        /// <summary>
+        ///     Creates an external context and attaches it to the calling thread. Called when a thread attaches to a scheduler.
+        /// </summary>
+        ExternalContextBase *AttachExternalContext(bool explicitAttach);
+
+        /// <summary>
+        ///     Detaches an external context from the scheduler it is attached to. Called when an external context actively detaches
+        ///     from a scheduler, or when the underlying thread for an implicitly attached external context exits.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The external context being detached.
+        /// </param>
+        /// <param name="explicitDetach">
+        ///     Whether this was the result of an explicit detach or the thread exiting.
+        /// </param>
+        void DetachExternalContext(ExternalContextBase* pContext, bool explicitDetach);
+
+        /// <summary>
+        ///     Gets an external context from the idle pool, creating a new one if the idle pool is empty.
+        /// </summary>
+        ExternalContextBase *GetExternalContext(bool explicitAttach);
+
+        ///<summary>
+        ///     Releases an external context of the to the scheduler's idle pool, destroying it if the idle pool is full.
+        ///</summary>
+        void ReleaseExternalContext(ExternalContextBase *pContext);
+
+        /// <summary>
+        ///     Increments the reference count to the scheduler but does not allow a 0 to 1 transition. This API should
+        ///     be used to safely access a scheduler when the scheduler is not 'owned' by the caller.
+        /// </summary>
+        /// <returns>
+        ///     True if the scheduler was referenced, false, if the reference count was 0.
+        /// </returns>
+        bool SafeReference();
+
+        /// <summary>
+        ///     Returns the default scheduler creating one if it doesn't exist.
+        /// </summary>
+        /// <returns>
+        ///     A pointer to the default scheduler
+        /// </returns>
+        static SchedulerBase* GetDefaultScheduler();
+
+        //
+        // Finalization:
+        //
+
+        /// <summary>
+        ///     Called to initiate shutdown of the scheduler.  This may directly proceed to phase two of shutdown (actively
+        ///     shutting down internal contexts) or it may wait for additional events (e.g.: all work to complete) before
+        ///     proceeding to phase two.
+        /// </summary>
+        void PhaseOneShutdown();
+
+        /// <summary>
+        ///     Actively informs all internal contexts to exit and breaks them out of their dispatch loops.  When the last
+        ///     internal context dies, finalization will occur and we move to SchedulerBase::Finalize().
+        /// </summary>
+        void PhaseTwoShutdown();
+
+        /// <summary>
+        ///     Performs finalization of the scheduler deleting all structures, etc...  This will also notify any listeners
+        ///     that the scheduler has actively shut down.
+        /// </summary>
+        void Finalize();
+
+        /// <summary>
+        ///     Once all virtual processors are idle, the scheduler calls this routine which performs a full sweep through all
+        ///     schedule groups looking for work.  If work is found (even a blocked context), the scheduler backs off finalization;
+        ///     otherwise, it proceeds by asking all virtual processors for final check-in.
+        /// </summary>
+        void SweepSchedulerForFinalize();
+
+        /// <summary>
+        ///     Releases virtual processors that were suspended on the shutdown gate, while trying to go from IDLE to
+        ///     ACTIVE when the finalization sweep was in progress.
+        /// </summary>
+        /// <param name="releaseCount">
+        ///     Number of virtual processors that need to be released.
+        /// </param>
+        void ReleaseSuspendedVirtualProcessors(LONG releaseCount);
+
+        /// <summary>
+        ///     Called during scheduler finalization, after all virtual processors are suspended to check if any chores still
+        ///     exist in the scheduler. The calling thread is the only thread active in the scheduler at the time the function
+        ///     is called.
+        /// </summary>
+        /// <returns>
+        ///     A boolean value indicating whether any unstarted chores (realized or unrealized) were found.
+        /// </returns>
+        bool FoundUnstartedChores();
+
+        /// <summary>
+        ///     Called during scheduler finalization, before all virtual processors are suspended to check if any blocked
+        ///     contexts exist in the scheduler.
+        /// </summary>
+        /// <returns>
+        ///     A boolean value indicating whether any blocked contexts were found.
+        /// </returns>
+        bool FoundBlockedContexts();
+
+        ///<summary>
+        ///     Called to perform a resurrection of the scheduler.  When the scheduler reference count has fallen to zero,
+        ///     it's possible there's still work on the scheduler and that one of those work items will perform an action
+        ///     leading to additional reference.  Such bringing of the reference count from zero to non-zero is only legal
+        ///     on an *INTERNAL* context and immediately halts shutdown.
+        ///</summary>
+        void Resurrect();
+
+        /// <summary>
+        ///     Called to perform a commit of safe-point registrations up to **AND INCLUDING** a particular version.
+        /// </summary>
+        /// <param name="commitVersion">
+        ///     The data version that we commit to.  A version of zero indicates a full commit.
+        /// </param>
+        void CommitToVersion(ULONG commitVersion);
+
+        /// <summary>
+        ///     Returns the commit version for safe points within the scheduler.
+        /// </summary>
+        ULONG ComputeSafePointCommitVersion();
+
+        /// <summary>
+        ///     Updates and returns the pending version for safe point commits.
+        ///     If there are no commits pending, 0 is returned.
+        /// </summary>
+        ULONG UpdatePendingVersion();
+
+        /// <summary>
+        ///     Updates the commit version to the given version and returns
+        ///     the pending commit version. If there are no commits pending, 0 is returned.
+        /// </summary>
+        /// <param name="commitVersion">
+        ///     The version up to which safe points have been committed.
+        /// </param>
+        ULONG UpdateCommitVersion(ULONG commitVersion);
+
+        /// <summary>
+        ///     Returns whether a particular version number is visible to us yet.  Versions at the wrap-around point
+        ///     are not visible until we commit the wrap.
+        /// </summary>
+        bool IsVisibleVersion(ULONG version)
+        {
+            return (version >= m_safePointCommitVersion);
+        }
+
+        /// <summary>
+        ///     Returns the version we are allowed to see from an observation.  This handles wrap around.
+        /// </summary>
+        ULONG ObservedVersion(ULONG version)
+        {
+            return (IsVisibleVersion(version) ? version : ULONG_MAX);
+        }
+
+        /// <summary>
+        ///     Publishes a new data version and returns the version number.
+        /// </summary>
+        ULONG PublishNewDataVersion()
+        {
+            ULONG dataVersion = InterlockedIncrement(reinterpret_cast<volatile LONG *>(&m_safePointDataVersion));
+
+            //
+            // Zero and ULONG_MAX are special keys used to handle wrap-around in the version counters.  The commit counter may never be either of these values due
+            // to a data version being them.
+            //
+            while (dataVersion == 0 || dataVersion == ULONG_MAX)
+                dataVersion = InterlockedIncrement(reinterpret_cast<volatile LONG *>(&m_safePointDataVersion));
+
+            return dataVersion;
+        }
+
+        /// <summary>
+        ///     Registers a callback at the next safe point after this function call.  This should never be directly used by clients.
+        ///     SafePointInvocation::Register(...) should be used instead.
+        /// </summary>
+        /// <param name="pInvocation">
+        ///     The invocation object which is being registered.
+        /// </param>
+        void InvokeOnSafePoint(SafePointInvocation *pInvocation);
+
+        /// <summary>
+        ///     Send a scheduler ETW event
+        /// </summary>
+        void TraceSchedulerEvent(ConcRT_EventType eventType, UCHAR level, unsigned int schedulerId)
+        {
+            if (g_TraceInfo._IsEnabled(level, SchedulerEventFlag))
+                ThrowSchedulerEvent(eventType, level, schedulerId);
+        }
+
+        /// <summary>
+        ///     Changes the due time for dispatching new threads
+        /// </summary>
+        void ChangeThrottlingTimer(ULONG dueTime);
+
+        /// <summary>
+        ///     Acts as a trampoline between the event wait and the timer wait as we cannot queue the timer in DeferredGetInternalContext
+        ///     due to limitations on what Win32 APIs can be called from a UMS primary.
+        /// </summary>
+        static void CALLBACK ThrottlerTrampoline(PVOID pData, BOOLEAN waitOrTimerFired);
+
+        /// <summary>
+        ///     Creates new contexts.
+        /// </summary>
+        void ThrottlerDispatch();
+
+        /// <summary>
+        ///     Called to notify the scheduler that a context is available from the throttling manager / background creation.
+        /// </summary>
+        /// <returns>
+        ///     An indication of whether a virtual processor was awoken due to the context being utilized.
+        /// </returns>
+        bool NotifyThrottledContext(InternalContextBase *pContext);
+
+        /// <summary>
+        ///     Create a schedule group within this scheduler.
+        /// </summary>
+        /// <param name="pPlacement">
+        ///     A pointer to a location where tasks within the schedule group will be biased towards executing at.
+        /// </param>
+        /// <returns>
+        ///     A pointer to a newly created schedule group.
+        /// </returns>
+        ScheduleGroup* InternalCreateScheduleGroup(location* pPlacement);
+
+        /// <summary>
+        ///    Internal claim of a quick cache slot.
+        /// </summary>
+        ScheduleGroupSegmentBase *ActualGetQuickCacheSlot(unsigned int maskId)
+        {
+            ScheduleGroupSegmentBase *pSegment = m_pCoreAffinityQuickCache[static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT];
+
+            if (pSegment > reinterpret_cast<ScheduleGroupSegmentBase *>(1))
+            {
+                ScheduleGroupSegmentBase *pXchgSegment = reinterpret_cast <ScheduleGroupSegmentBase *> (
+                    InterlockedCompareExchangePointer(reinterpret_cast <void * volatile *> (m_pCoreAffinityQuickCache + (static_cast<size_t>(maskId) << QUICKCACHEPAD_SHIFT)),
+                                                      reinterpret_cast <void *> (1),
+                                                      reinterpret_cast <void *> (pSegment))
+                    );
+
+                if (pSegment == pXchgSegment)
+                    return pSegment;
+            }
+
+            return NULL;
+        }
+
+        /// <summary>
+        ///     Performs the scheduler service scan.
+        /// </summary>
+        void PerformServiceScan(ULONGLONG serviceTime);
+
+        /// <summary>
+        ///     A simple bridge to ThrottlerDispatch. This bridge is used for Vista and up (except MSDK)
+        /// </summary>
+        static void CALLBACK ThrottlerDispatchBridge(PTP_CALLBACK_INSTANCE, void * pContext, PTP_TIMER)
+        {
+            ThrottlerDispatchBridgeXP(pContext, true);
+        }
+
+        /// <summary>
+        ///     A simple bridge to ThrottlerDispatch. This bridge is used for XP and MSDK
+        /// </summary>
+        static void CALLBACK ThrottlerDispatchBridgeXP(PVOID pScheduler, BOOLEAN)
+        {
+            reinterpret_cast<SchedulerBase *>(pScheduler)->ThrottlerDispatch();
+        }
+
+        static void ThrowSchedulerEvent(ConcRT_EventType eventType, UCHAR level, unsigned int schedulerId);
+
+        // Hide assignment operator and copy constructor
+        SchedulerBase const &operator =(SchedulerBase const &);
+        SchedulerBase(SchedulerBase const &);
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulerPolicyBase.cpp

@@ -0,0 +1,437 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulerPolicyBase.cpp
+//
+// Scheduler policy implementation
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Internal list of scheduler policy defaults.
+    /// </summary>
+    const unsigned int PolicyDefaults[] =
+    {
+        ::Concurrency::ThreadScheduler, // SchedulerKind
+        MaxExecutionResources,          // MaxConcurrency
+        1,                              // MinConcurrency
+        1,                              // TargetOversubscriptionFactor
+        8,                              // LocalContextCacheSize
+        0,                              // ContextStackSize
+        THREAD_PRIORITY_NORMAL,         // ContextPriority
+        EnhanceScheduleGroupLocality,   // SchedulingProtocol
+        ProgressFeedbackEnabled,        // DynamicProgressFeedback
+        InitializeWinRTAsMTA,           // WinRTInitialization
+    };
+
+    /// <summary>
+    ///     Internal map from policy keys to descriptive strings.
+    /// </summary>
+    const char* const PolicyElementKeyStrings[] =
+    {
+        "SchedulerKind",
+        "MaxConcurrency",
+        "MinConcurrency",
+        "TargetOversubscriptionFactor",
+        "LocalContextCacheSize",
+        "ContextStackSize",
+        "ContextPriority",
+        "SchedulingProtocol",
+        "DynamicProgressFeedback",
+        "WinRTInitialization",
+        "MaxPolicyElementKey"
+    };
+}
+
+    /// <summary>
+    ///     Creates a new default scheduler policy.
+    /// </summary>
+    SchedulerPolicy::SchedulerPolicy()
+    {
+        _Initialize(0, NULL);
+    }
+
+    /// <summary>
+    ///     Creates a new scheduler policy that uses a named-parameter style of initialization.  Unnamed parameters take defaults described above.
+    /// </summary>
+    SchedulerPolicy::SchedulerPolicy(size_t _PolicyKeyCount, ...)
+    {
+        va_list args;
+        va_start(args, _PolicyKeyCount);
+        _Initialize(_PolicyKeyCount, &args);
+    }
+
+    /// <summary>
+    ///     Initializes the scheduler policy.
+    /// </summary>
+    void SchedulerPolicy::_Initialize(size_t _PolicyKeyCount, va_list *_PArgs)
+    {
+        size_t bagSize = sizeof(unsigned int) * Concurrency::MaxPolicyElementKey;
+        _PolicyBag *pPolicyBag = _concrt_new _PolicyBag;
+        _M_pPolicyBag = pPolicyBag;
+
+        try
+        {
+            memcpy(pPolicyBag->_M_values._M_pPolicyBag, PolicyDefaults, bagSize);
+
+            for (size_t i = 0; i < _PolicyKeyCount; i++)
+            {
+                PolicyElementKey key = va_arg(*_PArgs, PolicyElementKey);
+                unsigned int value = va_arg(*_PArgs, unsigned int);
+
+                if ( !_ValidPolicyKey(key))
+                    throw invalid_scheduler_policy_key(_StringFromPolicyKey(key));
+
+                if ( !_ValidPolicyValue(key, value))
+                     throw invalid_scheduler_policy_value(_StringFromPolicyKey(key));
+
+                pPolicyBag->_M_values._M_pPolicyBag[key] = value;
+            }
+
+            if (!_AreConcurrencyLimitsValid())
+            {
+                throw invalid_scheduler_policy_thread_specification();
+            }
+
+            if (!_ArePolicyCombinationsValid())
+            {
+                throw invalid_scheduler_policy_value();
+            }
+
+            _ResolvePolicyValues();
+
+        }
+        catch (...)
+        {
+            delete pPolicyBag;
+            throw;
+        }
+    }
+
+    /// <summary>
+    ///     The most convenient way to define a new scheduler policy is to copy
+    ///     an existing policy and modify it. The copy constructor is also needed
+    ///     for all the usual reasons.
+    /// </summary>
+    SchedulerPolicy::SchedulerPolicy(const SchedulerPolicy &srcPolicy)
+    {
+        _M_pPolicyBag = _concrt_new _PolicyBag;
+        _Assign(srcPolicy);
+    }
+
+    /// <summary>
+    ///     The most convenient way to define a new scheduler policy is to copy
+    ///     an existing policy and modify it. The copy constructor is also needed
+    ///     for all the usual reasons.
+    /// </summary>
+    SchedulerPolicy& SchedulerPolicy::operator=(const SchedulerPolicy &rhsPolicy)
+    {
+        _Assign(rhsPolicy);
+        return *this;
+    }
+
+    /// <summary>
+    ///     Make this policy a copy of the source policy.
+    /// </summary>
+    void SchedulerPolicy::_Assign(const SchedulerPolicy &rhsPolicy)
+    {
+        size_t bagSize = sizeof(unsigned int) * Concurrency::MaxPolicyElementKey;
+        memcpy(_M_pPolicyBag->_M_values._M_pPolicyBag, rhsPolicy._M_pPolicyBag->_M_values._M_pPolicyBag, bagSize);
+    }
+
+    /// <summary>
+    ///     Destroys a scheduler policy.
+    /// </summary>
+    SchedulerPolicy::~SchedulerPolicy()
+    {
+        delete _M_pPolicyBag;
+    }
+
+    /// <summary>
+    ///     Retrieve the value of the supplied policy key.
+    /// </summary>
+    /// <param name="key">
+    ///     [in] The policy key.
+    /// </param>
+    /// <returns>
+    ///     The policy key value for the key, if is a supported key.
+    /// </returns>
+    /// <remarks>
+    ///     The function will throw "invalid_scheduler_policy_key" for any key that is not supported.
+    /// </remarks>
+    unsigned int SchedulerPolicy::GetPolicyValue(PolicyElementKey key) const
+    {
+        if (!_ValidPolicyKey(key))
+        {
+            throw invalid_scheduler_policy_key(_StringFromPolicyKey(key));
+        }
+
+        return _M_pPolicyBag->_M_values._M_pPolicyBag[key];
+    }
+
+    /// <summary>
+    ///     Set the value of the supplied policy key and return the old value.
+    /// </summary>
+    /// <param name="key">
+    ///     [in] The policy key.
+    /// </param>
+    /// <param name="value">
+    ///     [in] The value for the policy key.
+    /// </param>
+    /// <returns>
+    ///     The old policy key value for the key, if is a supported key.
+    /// </returns>
+    /// <remarks>
+    ///     The function will throw "invalid_scheduler_policy_key" for any key that is not supported,
+    ///     and "invalid_scheduler_policy_value" for a value that is not supported for a valid key.
+    /// </remarks>
+    unsigned int SchedulerPolicy::SetPolicyValue(PolicyElementKey key, unsigned int value)
+    {
+        if (!_ValidPolicyKey(key)
+            || key == ::Concurrency::MinConcurrency
+            || key == ::Concurrency::MaxConcurrency)
+        {
+            throw invalid_scheduler_policy_key(_StringFromPolicyKey(key));
+        }
+
+        if (!_ValidPolicyValue(key, value))
+        {
+            throw invalid_scheduler_policy_value(_StringFromPolicyKey(key));
+        }
+
+        unsigned int oldValue = GetPolicyValue(key);
+        _M_pPolicyBag->_M_values._M_pPolicyBag[key] = value;
+
+        _ResolvePolicyValues();
+        return oldValue;
+    }
+
+    /// <summary>
+    ///     Set the value of the supplied policy key and return the old value.
+    /// </summary>
+    /// <param name="_MinConcurrency">
+    ///     The value for MinConcurrency.
+    /// </param>
+    /// <param name="_MaxConcurrency">
+    ///     The value for MaxConcurrency.
+    /// </param>
+    /// <remarks>
+    ///     The function will throw "invalid_scheduler_policy_value" if:
+    ///     _MaxConcurrency != MaxExecutionResources && _MinConcurrency > _MaxConcurrency
+    ///</remarks>
+    void SchedulerPolicy::SetConcurrencyLimits(unsigned int _MinConcurrency, unsigned int _MaxConcurrency)
+    {
+        if (!_ValidPolicyValue(::Concurrency::MaxConcurrency, _MaxConcurrency))
+            throw invalid_scheduler_policy_value(_StringFromPolicyKey(::Concurrency::MaxConcurrency));
+
+        if (!_ValidPolicyValue(::Concurrency::MinConcurrency, _MinConcurrency))
+            throw invalid_scheduler_policy_value(_StringFromPolicyKey(::Concurrency::MinConcurrency));
+
+        if (!_AreConcurrencyLimitsValid(_MinConcurrency, _MaxConcurrency))
+            throw invalid_scheduler_policy_thread_specification();
+
+        if (!_ArePolicyCombinationsValid())
+            throw invalid_scheduler_policy_value();
+
+        _M_pPolicyBag->_M_values._M_pPolicyBag[::Concurrency::MaxConcurrency] = _MaxConcurrency;
+        _M_pPolicyBag->_M_values._M_pPolicyBag[::Concurrency::MinConcurrency] = _MinConcurrency;
+
+        _ResolvePolicyValues();
+    }
+
+    /// <summary>
+    ///     Resolves some of the policy keys that are set to defaults, based on the characteristics of the underlying system.
+    /// </summary>
+    void SchedulerPolicy::_ResolvePolicyValues()
+    {
+        // Resolve the SchedulerKind policy key value.
+        _M_pPolicyBag->_M_values._M_pPolicyBag[::Concurrency::SchedulerKind] = ::Concurrency::ThreadScheduler;
+
+        // Resolve MinConcurrency and MaxConcurrency, if either of them are set to the special value MaxExecutionResources.
+        unsigned int coreCount = ::Concurrency::GetProcessorCount();
+        ASSERT((coreCount > 0) && (coreCount <= INT_MAX));
+
+        if (_M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency] == MaxExecutionResources)
+        {
+            if (_M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] == MaxExecutionResources)
+            {
+                // [1] Both the keys are set to MaxExecutionResources.
+                _M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency] = _M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] = coreCount;
+            }
+            else
+            {
+                // [2] MinConcurrency is set to MaxExecutionResources.
+                _M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency] = (_M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] < coreCount) ?
+                    _M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] : coreCount;
+            }
+        }
+        else if (_M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] == MaxExecutionResources)
+        {
+            // [3] MaxConcurrency is set to MaxExecutionResources.
+            _M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] = (_M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency] > coreCount) ?
+                _M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency] : coreCount;
+        }
+
+        ASSERT(_M_pPolicyBag->_M_values._M_pPolicyBag[MaxConcurrency] >= _M_pPolicyBag->_M_values._M_pPolicyBag[MinConcurrency]);
+    }
+
+
+    const char* SchedulerPolicy::_StringFromPolicyKey(unsigned int index)
+    {
+        if (index > ::Concurrency::MaxPolicyElementKey)
+            index = ::Concurrency::MaxPolicyElementKey;
+
+        return PolicyElementKeyStrings[index];
+    }
+
+    bool SchedulerPolicy::_ValidPolicyKey(PolicyElementKey key)
+    {
+        return (key >= SchedulerKind && key < MaxPolicyElementKey);
+    }
+
+    bool SchedulerPolicy::_ValidPolicyValue(PolicyElementKey key, unsigned int value)
+    {
+        bool valid = true;
+
+        switch (key)
+        {
+        case ::Concurrency::SchedulerKind:
+            if ( value != ::Concurrency::ThreadScheduler )
+            {
+                valid = false;
+            }
+            break;
+        case ::Concurrency::ContextPriority:
+            {
+                int priority = (int)value;
+                //
+                // The win32 api accepts values [-7, 7), 15 and -15 for threads other than the current thread.
+                // In addition, we define a special value INHERIT_THREAD_PRIORITY, whereby the internal contexts
+                // inherit the priority of the thread creating the scheduler
+                //
+                if ( !(priority >= -7 && priority < 7
+                    || priority == 15
+                    || priority == -15
+                    || priority == INHERIT_THREAD_PRIORITY))
+                {
+                    valid = false;
+                }
+            }
+            break;
+        case ::Concurrency::SchedulingProtocol:
+            if ( !(value == ::Concurrency::EnhanceScheduleGroupLocality
+                || value == ::Concurrency::EnhanceForwardProgress))
+            {
+                valid = false;
+            }
+            break;
+        case ::Concurrency::MaxConcurrency:
+            if ( !((value > 0 && value <= INT_MAX) || value == MaxExecutionResources))
+            {
+                valid = false;
+            }
+            break;
+        case ::Concurrency::MinConcurrency:
+            if ( !((value <= INT_MAX) || value == MaxExecutionResources))
+            {
+                valid = false;
+            }
+            break;
+        case ::Concurrency::LocalContextCacheSize:
+        case ::Concurrency::ContextStackSize:
+            if ( !(value <= INT_MAX))
+            {
+                valid = false;
+            }
+            break;
+        case ::Concurrency::TargetOversubscriptionFactor:
+            if ( !(value > 0 && value <= INT_MAX))
+            {
+                valid = false;
+            }
+            break;
+
+        case ::Concurrency::DynamicProgressFeedback:
+            if ( !(value == ::Concurrency::ProgressFeedbackEnabled || value == ::Concurrency::ProgressFeedbackDisabled))
+            {
+                valid = false;
+            }
+            break;
+
+        case ::Concurrency::WinRTInitialization:
+            if ( !(value == ::Concurrency::InitializeWinRTAsMTA || value == ::Concurrency::DoNotInitializeWinRT))
+            {
+                valid = false;
+            }
+            break;
+
+        case ::Concurrency::MaxPolicyElementKey:
+        default:
+            terminate();
+        }
+
+        return valid;
+    }
+
+    void SchedulerPolicy::_ValidateConcRTPolicy() const
+    {
+        unsigned int minConcurrency = GetPolicyValue(::Concurrency::MinConcurrency);
+        if (minConcurrency == 0)
+        {
+            throw invalid_scheduler_policy_value(_StringFromPolicyKey(::Concurrency::MinConcurrency));
+        }
+
+        ::Concurrency::DynamicProgressFeedbackType dynamicProgress =
+            (::Concurrency::DynamicProgressFeedbackType) GetPolicyValue(::Concurrency::DynamicProgressFeedback);
+
+        if (dynamicProgress == ProgressFeedbackDisabled)
+        {
+            throw invalid_scheduler_policy_value(_StringFromPolicyKey(::Concurrency::DynamicProgressFeedback));
+        }
+    }
+
+    /// <summary>
+    ///     Test a policy's concurrency limits.
+    /// </summary>
+    bool SchedulerPolicy::_AreConcurrencyLimitsValid(unsigned int _MinConcurrency, unsigned int _MaxConcurrency)
+    {
+        // For concurrency limits that are != MaxExecutionResource, plug into the equation: _MinConcurrency <= _MaxConcurrency,
+        // and return false, if it does not hold.
+
+        // Validate Max
+        if ((_MaxConcurrency != MaxExecutionResources)
+            && (_MinConcurrency != MaxExecutionResources) && (_MaxConcurrency < _MinConcurrency))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Test a policy's concurrency limits.
+    /// </summary>
+    bool SchedulerPolicy::_AreConcurrencyLimitsValid() const
+    {
+        return _AreConcurrencyLimitsValid(GetPolicyValue(::Concurrency::MinConcurrency),
+                                    GetPolicyValue(::Concurrency::MaxConcurrency));
+    }
+
+    /// <summary>
+    ///     Test a policy's concurrency limits.
+    /// </summary>
+    bool SchedulerPolicy::_ArePolicyCombinationsValid() const
+    {
+        return true;
+    }
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulerProxy.cpp

@@ -0,0 +1,1237 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulerProxy.cpp
+//
+// RM proxy for a scheduler instance
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+#pragma warning (push)
+#pragma warning (disable : 4702)
+    /// <summary>
+    ///     Constructs a scheduler proxy.
+    /// </summary>
+    SchedulerProxy::SchedulerProxy(IScheduler * pScheduler, ResourceManager * pResourceManager, const SchedulerPolicy &policy)
+        : m_pThreadProxyFactory(nullptr)
+        , m_pResourceManager(pResourceManager)
+        , m_pHillClimbing(nullptr)
+        , m_staticData{}
+        , m_queueLength(0)
+        , m_currentConcurrency(0)
+        , m_numAllocatedCores(0)
+        , m_numBorrowedCores(0)
+        , m_numFixedCores(0)
+        , m_numAssignedThreads(0)
+        , m_numExternalThreads(0)
+        , m_numExternalThreadCores(0)
+    {
+        ASSERT(pScheduler != NULL);
+
+        m_pScheduler = pScheduler;
+
+        m_maxConcurrency                = policy.GetPolicyValue(::Concurrency::MaxConcurrency);
+        m_minConcurrency                = policy.GetPolicyValue(::Concurrency::MinConcurrency);
+        m_targetOversubscriptionFactor  = policy.GetPolicyValue(::Concurrency::TargetOversubscriptionFactor);
+        m_contextStackSize              = policy.GetPolicyValue(::Concurrency::ContextStackSize);
+        m_contextPriority               = policy.GetPolicyValue(::Concurrency::ContextPriority);
+        m_fDoHillClimbing               = policy.GetPolicyValue(::Concurrency::DynamicProgressFeedback) == ::Concurrency::ProgressFeedbackEnabled;
+
+        if (m_contextPriority == INHERIT_THREAD_PRIORITY)
+        {
+            m_contextPriority = (char) platform::__GetThreadPriority(GetCurrentThread());
+        }
+
+        m_id = m_pScheduler->GetId();
+        ASSERT(m_id != -1);
+
+        unsigned int coreCount = m_pResourceManager->GetCoreCount();
+
+        m_coreCount = coreCount;
+
+        ASSERT(coreCount > 0 && coreCount <= INT_MAX);
+        ASSERT(m_maxConcurrency > 0 && m_maxConcurrency >= m_minConcurrency);
+
+        unsigned int originalTof = m_targetOversubscriptionFactor;
+
+        // Find the minimum target oversubscription factor required to satisfy MaxConcurrency with the cores available.
+        unsigned int minTof = (m_maxConcurrency + coreCount - 1)/coreCount;
+
+        if (originalTof < minTof)
+        {
+            // Adjust target oversubscription factor to ensure that we can satisfy MaxConcurrency with the cores on the system.
+            m_targetOversubscriptionFactor  = minTof;
+            // The scheduler needs all the cores on the machine to satisfy max threads. Moreover we will need to oversubscribe
+            // more than the user indicated.
+            m_desiredHardwareThreads = coreCount;
+        }
+        else
+        {
+            m_desiredHardwareThreads = (m_maxConcurrency + originalTof - 1)/originalTof;
+        }
+
+        // Now adjust target oversubscription factor to ensure that MaxConcurrency virtual processors are evenly distributed
+        // over the desired number of hardware threads (i.e each core gets either m_tof vprocs or m_tof - 1 vprocs). Also
+        // calculate how many of the assigned cores will get m_tof vprocs.
+        if ((m_maxConcurrency % m_desiredHardwareThreads) == 0)
+        {
+            // This is the common case. We have a simple distribution and every allocated core will get tof vprocs.
+            m_targetOversubscriptionFactor = m_maxConcurrency/m_desiredHardwareThreads;
+            m_numFullySubscribedCores = m_desiredHardwareThreads;
+            m_minimumHardwareThreads = (m_minConcurrency + m_targetOversubscriptionFactor - 1)/m_targetOversubscriptionFactor;
+        }
+        else
+        {
+            // We have an uneven distribution; some cores will get tof vprocs and some will get tof - 1.
+            ASSERT(m_targetOversubscriptionFactor > 1);
+
+            m_targetOversubscriptionFactor = (m_maxConcurrency + m_desiredHardwareThreads - 1)/m_desiredHardwareThreads;
+            m_numFullySubscribedCores = m_desiredHardwareThreads - ((m_desiredHardwareThreads * m_targetOversubscriptionFactor) - m_maxConcurrency);
+
+            // Calculate min hardware threads. We need to make sure that given the way vprocs are distributed to cores
+            // (where some cores could get tof vprocs and some could get tof - 1 vprocs), the scheduler proxy will never go below
+            // min concurrency if it is left with just the minimum number of cores (and all of those cores happen to have tof -1
+            // vprocs assigned to them).
+            if (((m_desiredHardwareThreads - m_numFullySubscribedCores) * (m_targetOversubscriptionFactor - 1)) >= m_minConcurrency)
+            {
+                m_minimumHardwareThreads = (m_minConcurrency + m_targetOversubscriptionFactor - 2)/(m_targetOversubscriptionFactor - 1);
+            }
+            else
+            {
+                m_minimumHardwareThreads = (m_desiredHardwareThreads - m_numFullySubscribedCores);
+
+                unsigned int remainingThreads = (m_minConcurrency - (m_minimumHardwareThreads * (m_targetOversubscriptionFactor - 1)));
+                ASSERT(remainingThreads < m_minConcurrency);
+                m_minimumHardwareThreads += (remainingThreads + m_targetOversubscriptionFactor - 1)/m_targetOversubscriptionFactor;
+            }
+        }
+
+        ASSERT(m_maxConcurrency <= m_targetOversubscriptionFactor * m_desiredHardwareThreads);
+        ASSERT(m_numFullySubscribedCores <= m_desiredHardwareThreads);
+        ASSERT(m_targetOversubscriptionFactor > 1 || m_numFullySubscribedCores == m_desiredHardwareThreads);
+
+        ASSERT(m_targetOversubscriptionFactor > 0 && m_targetOversubscriptionFactor <= INT_MAX);
+        ASSERT(m_desiredHardwareThreads > 0 && m_desiredHardwareThreads <= coreCount);
+        ASSERT(m_desiredHardwareThreads > 0 && m_minimumHardwareThreads <= m_desiredHardwareThreads);
+
+        // Hold a reference to the resource manager.
+        int ref = m_pResourceManager->Reference();
+        (ref);
+        CONCRT_COREASSERT(ref > 1);
+
+        if (m_fDoHillClimbing)
+        {
+            m_pHillClimbing = _concrt_new HillClimbing(m_id, coreCount, this);
+        }
+
+        m_nodeCount = GetProcessorNodeCount();
+        // The allocated nodes structure is created when the first allocation is made for this scheduler proxy. We need to read global core
+        // state during this allocation, and therefore we need to perform it while holding the RM lock.
+        m_pAllocatedNodes = NULL;
+
+        m_pSortedNodeOrder = _concrt_new unsigned int[m_nodeCount];
+        for (unsigned int i = 0; i < m_nodeCount; ++i)
+        {
+            m_pSortedNodeOrder[i] = i;
+        }
+
+#if defined(CONCRT_TRACING)
+        m_drmInitialState = NULL;
+#endif
+    }
+#pragma warning (pop)
+
+    /// <summary>
+    ///     Called by a scheduler in order make an initial request for an allocation of virtual processors.  The request
+    ///     is driven by policies within the scheduler queried via the IScheduler::GetPolicy method.  If the request
+    ///     can be satisfied via the rules of allocation, it is communicated to the scheduler as a call to
+    ///     IScheduler::AddVirtualProcessors.
+    /// </summary>
+    /// <param name="doSubscribeCurrentThread">
+    ///     Whether to subscribe the current thread and account for it during resource allocation.
+    /// </param>
+    /// <returns>
+    ///     The IExecutionResource instance representing current thread if doSubscribeCurrentThread was true; NULL otherwise.
+    /// </returns>
+    IExecutionResource * SchedulerProxy::RequestInitialVirtualProcessors(bool doSubscribeCurrentThread)
+    {
+        return m_pResourceManager->RequestInitialVirtualProcessors(this, doSubscribeCurrentThread);
+    }
+
+    /// <summary>
+    ///     Called in order to notify the resource manager that the given scheduler is shutting down.  This
+    ///     will cause the resource manager to immediately reclaim all resources granted to the scheduler.
+    /// </summary>
+    void SchedulerProxy::Shutdown()
+    {
+        m_pResourceManager->Shutdown(this);
+    }
+
+    /// <summary>
+    ///     Gets a new thread proxy from the factory.
+    /// </summary>
+    IThreadProxy * SchedulerProxy::GetNewThreadProxy(IExecutionContext * pContext)
+    {
+        if (m_pThreadProxyFactory == NULL)
+        {
+            // Populate the cached pointer from the one in the RM
+            m_pThreadProxyFactory = GetResourceManager()->GetThreadProxyFactoryManager()->GetFreeThreadProxyFactory();
+        }
+
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *>(m_pThreadProxyFactory->RequestProxy(ContextStackSize(), ContextPriority()));
+        pProxy->AssociateExecutionContext(pContext);
+
+        return pProxy;
+    }
+
+    /// <summary>
+    ///     Ensures that a context is bound to a thread proxy.  This API should *NOT* be called in the vast majority of circumstances.
+    ///     The IThreadProxy::SwitchTo will perform late binding to thread proxies as necessary.  There are, however, circumstances
+    ///     where it is necessary to pre-bind a context to ensure that the SwitchTo operation switches to an already bound context.  This
+    ///     is the case on a UMS scheduling context as it cannot call allocation APIs.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context to bind.
+    /// </param>
+    void SchedulerProxy::BindContext(IExecutionContext * pContext)
+    {
+        if (pContext == NULL)
+        {
+            throw std::invalid_argument("pContext");
+        }
+
+        // Find out if this context already has a thread proxy, if not we have to request one from the factory.
+        if (pContext->GetProxy() == NULL)
+        {
+            // Find a thread proxy from the pool that corresponds to the stack size and priority we need.
+            GetNewThreadProxy(pContext);
+        }
+    }
+
+    /// <summary>
+    ///     Returns an **unstarted** thread proxy attached to pContext, to the thread proxy factory.
+    ///     Such a thread proxy **must** be unstarted.
+    ///     This API should *NOT* be called in the vast majority of circumstances.
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context to unbind.
+    /// </param>
+    void SchedulerProxy::UnbindContext(IExecutionContext * pContext)
+    {
+        if (pContext == NULL)
+        {
+            throw std::invalid_argument("pContext");
+        }
+
+        FreeThreadProxy * pProxy = static_cast<FreeThreadProxy *> (pContext->GetProxy());
+
+        ASSERT(pProxy != NULL);
+        pProxy->ReturnIdleProxy();
+    }
+
+    /// <summary>
+    ///     This function retrieves the execution resource associated with this thread, if one exists
+    /// </summary>
+    /// <returns>
+    ///     The ExecutionResource instance representing current thread in the runtime.
+    /// </returns>
+    ExecutionResource * SchedulerProxy::GetCurrentThreadExecutionResource()
+    {
+        ExecutionResource * pExecutionResource = NULL;
+        DWORD tlsSlot = GetResourceManager()->GetExecutionResourceTls();
+        void * tlsPointer = platform::__TlsGetValue(tlsSlot);
+        size_t tlsValue = (size_t) tlsPointer;
+
+        if ((tlsPointer != NULL) && ((tlsValue & TlsResourceBitMask) == TlsResourceInResource))
+        {
+            pExecutionResource = (ExecutionResource *) tlsValue;
+        }
+
+        return pExecutionResource;
+    }
+
+    /// <summary>
+    ///     This function retrieves the execution resource associated with this thread, if one exists,
+    ///     and updates the reference count on it for better bookkeeping.
+    /// </summary>
+    /// <returns>
+    ///     The ExecutionResource instance representing current thread in the runtime.
+    /// </returns>
+    ExecutionResource * SchedulerProxy::ReferenceCurrentThreadExecutionResource()
+    {
+        ExecutionResource * pExecutionResource = NULL;
+        DWORD tlsSlot = GetResourceManager()->GetExecutionResourceTls();
+        void * tlsPointer = platform::__TlsGetValue(tlsSlot);
+
+        if (tlsPointer != NULL)
+        {
+            size_t tlsValue = (size_t) tlsPointer;
+
+            if ((tlsValue & TlsResourceBitMask) == TlsResourceInResource)
+            {
+                // The current thread was previously subscribed with the RM.
+                pExecutionResource = (ExecutionResource *) tlsValue;
+
+                VirtualProcessorRoot * pVPRoot = pExecutionResource->GetVirtualProcessorRoot();
+
+                // If this is a nested subscribe call then if there was a virtual processor root,
+                // it could not have been removed, because it would have been marked as "fixed".
+                ASSERT(pVPRoot == NULL || !pVPRoot->IsRootRemoved());
+                pExecutionResource->IncrementUseCounts();
+            }
+            else if ((tlsValue & TlsResourceBitMask) == TlsResourceInProxy)
+            {
+                // The current thread is a thread proxy.
+                FreeThreadProxy * pThreadProxy = (FreeThreadProxy *) (((size_t) tlsValue) & ~TlsResourceInProxy);
+                pExecutionResource = pThreadProxy->GetVirtualProcessorRoot()->GetExecutionResource();
+                VirtualProcessorRoot * pVPRoot = pExecutionResource->GetVirtualProcessorRoot();
+                if (pVPRoot != NULL && pVPRoot->IsRootRemoved())
+                {
+                    // The virtual processor root that this thread is running on has been removed. We have to
+                    // create a new execution resource abstraction for the current thread and perform an external
+                    // thread allocation for this scheduler proxy.
+                    pExecutionResource = NULL;
+                }
+                else
+                {
+                    pExecutionResource->IncrementUseCounts();
+                }
+            }
+        }
+
+        if (pExecutionResource != NULL)
+        {
+            return GetResourceForNewSubscription(pExecutionResource);
+        }
+
+        return pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Creates or reuses an execution resource for the thread subscription
+    /// </summary>
+    ExecutionResource * SchedulerProxy::GetResourceForNewSubscription(ExecutionResource * pParentExecutionResource)
+    {
+        ExecutionResource * pExecutionResource = NULL;
+
+        if (pParentExecutionResource->GetSchedulerProxy() != this)
+        {
+            pExecutionResource = _concrt_new ExecutionResource(this, pParentExecutionResource);
+            pExecutionResource->IncrementUseCounts();
+        }
+        else
+        {
+            pExecutionResource = pParentExecutionResource;
+        }
+
+        return pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Registers that a call to SubscribeCurrentThread has occurred for this core, making this core immovable.
+    /// </summary>
+    void SchedulerProxy::IncrementFixedCoreCount(unsigned int nodeId, unsigned int coreIndex, bool isExternalThread)
+    {
+        SchedulerCore * pCore = &m_pAllocatedNodes[nodeId].m_pCores[coreIndex];
+        if (pCore->m_numFixedThreads++ == 0)
+        {
+            SchedulerNode * pNode = &m_pAllocatedNodes[nodeId];
+            pNode->m_numFixedCores++;
+            m_numFixedCores++;
+            if (pCore->IsBorrowed())
+            {
+                // When a core becomes fixed, we temporarily remove the borrowed flag on it, and restore it when it
+                // becomes movable again.
+                pCore->m_fPreviouslyBorrowed = true;
+                ToggleBorrowedState(pNode, coreIndex);
+            }
+
+            // If this core has no virtual processors on it, count it as a core exclusively dedicated to external threads.
+            if (isExternalThread &&  m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_numAssignedThreads == 0)
+            {
+                ++m_numExternalThreadCores;
+            }
+        }
+
+        // Increment the external thread count on the core, which helps account for all the resources running on that core.
+        if (isExternalThread)
+        {
+            m_numExternalThreads++;
+            pCore->m_numExternalThreads++;
+        }
+    }
+
+    /// <summary>
+    ///     Registers that a call to IExecutionResource::Release has occurred, potentially freeing this core.
+    /// </summary>
+    void SchedulerProxy::DecrementFixedCoreCount(unsigned int nodeId, unsigned int coreIndex, bool isExternalThread)
+    {
+        SchedulerCore * pCore = &m_pAllocatedNodes[nodeId].m_pCores[coreIndex];
+        // Decrement external thread count on the core which helps account for all the resources running on that core.
+        if (isExternalThread)
+        {
+            ASSERT(pCore->m_numExternalThreads > 0);
+            pCore->m_numExternalThreads--;
+            m_numExternalThreads--;
+        }
+
+        ASSERT(pCore->m_numFixedThreads > 0);
+        if (--pCore->m_numFixedThreads == 0)
+        {
+            SchedulerNode * pNode = &m_pAllocatedNodes[nodeId];
+            ASSERT(pCore->m_numExternalThreads == 0);
+            m_numFixedCores--;
+            pNode->m_numFixedCores--;
+
+            if (pCore->m_fPreviouslyBorrowed)
+            {
+                // If this was a borrowed core convereted to fixed due to a subscription request, we restore the state
+                // back to borrowed, here.
+                ASSERT(!pCore->IsBorrowed());
+                ToggleBorrowedState(pNode, coreIndex);
+                pCore->m_fPreviouslyBorrowed = false;
+            }
+
+            // If this core was owned only due to an external thread being on it, then there is
+            // no more reason for it to be marked as such.
+            if (isExternalThread && m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_numAssignedThreads == 0)
+            {
+                m_numExternalThreadCores--;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     This API registers the current thread with the resource manager associating it with this scheduler proxy,
+    ///     and returns an instance of IExecutionResource back to the scheduler for bookkeeping and maintenance.
+    /// </summary>
+    /// <returns>
+    ///     The IExecutionResource instance representing current thread in the runtime.
+    /// </returns>
+    IExecutionResource * SchedulerProxy::SubscribeCurrentThread()
+    {
+        return m_pResourceManager->SubscribeCurrentThread(this);
+    }
+
+    /// <summary>
+    ///     Creates a new execution resource for the external thread and registers it with the scheduler proxy.
+    /// </summary>
+    ExecutionResource * SchedulerProxy::CreateExternalThreadResource(SchedulerNode * pNode, unsigned int coreIndex)
+    {
+        ExecutionResource * pExecutionResource = _concrt_new ExecutionResource(this, pNode, coreIndex);
+        pExecutionResource->IncrementUseCounts();
+        return pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Adds the execution resource to the list of subscribed threads
+    /// </summary>
+    void SchedulerProxy::AddThreadSubscription(ExecutionResource * pExecutionResource)
+    {
+        m_threadSubscriptions.AddTail(pExecutionResource);
+    }
+
+    /// <summary>
+    ///     Removes the execution resource from the list of subscribed threads
+    /// </summary>
+    void SchedulerProxy::RemoveThreadSubscription(ExecutionResource * pExecutionResource)
+    {
+        m_threadSubscriptions.Remove(pExecutionResource);
+        delete pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Called by the RM when it is done reserving cores for the scheduler proxy. The scheduler proxy allocates virtual processors
+    ///     or standalone execution resources based on the cores that were reserved for it.
+    /// </summary>
+    ExecutionResource * SchedulerProxy::GrantAllocation(unsigned int numberReserved, bool fInitialAllocation, bool fSubscribeCurrentThread)
+    {
+        ASSERT(m_numAllocatedCores == 0 || !fInitialAllocation);
+        ASSERT(m_numExternalThreads == 0 || !fInitialAllocation);
+
+        // The scheduler proxy's allocated node map contains 'numberReserved' cores that the RM has reserved in order to
+        // satisfy the proxy's request based on its request and the availability of resources. The cores are marked with
+        // ProcessorCore::Reserved, and will be converted to ProcessorCore::Allocated here.
+
+        // Note that 'numberReserved' could have the value 0, if this is an allocation for an external thread. In this case, depending
+        // on whether the scheduler has more than its minimum, we will either oversubscribe a core, or remove virtual processors
+        // assigned to a core in order to accommodate the external thread.
+        unsigned int reservationsAllocated = 0;
+        ExecutionResource * pExecutionResource = NULL;
+
+        ASSERT(!fInitialAllocation || m_minimumHardwareThreads == MinHWThreads());
+        // Calculate the number of virtual processors we will give this scheduler based on the core allocation
+        // we received. Each core will be allocated either m_tof vprocs or m_tof - 1 vprocs, based on the
+        // desired hardware threads and the value for max concurrency.
+
+        // The current thread subscription we are about to make does not contribute to MinHWThreads() at present. The external thread
+        // gets an exclusive core, if the remaining cores, allocated and reserved, can satisfy at least 1 more then the current minimum.
+        // Note that 'externalThreadCore' can be 1 even if no cores were reserved -> in this case we will have to remove vprocs from an allocated
+        // core and use it exclusively for the external thread.
+        unsigned int externalThreadCores = fSubscribeCurrentThread ? (m_numAllocatedCores + numberReserved > MinHWThreads() ? 1 : 0) : 0;
+        unsigned int vprocCores = (numberReserved > externalThreadCores) ? (numberReserved - externalThreadCores) : 0;
+        bool fRemoveVProcs = (externalThreadCores > 0 && numberReserved == 0);
+        bool fShareExternalThreadCore = (fSubscribeCurrentThread && externalThreadCores == 0);
+
+        // These variables are used if a thread subscription is part of this allocation. For a thread subscription assignment to a core,
+        // there are 3 possibilities:
+        //     1. A Reserved core exists in the current allocation map exclusive for the thread subscription.
+        //     2. The thread subscription will share a core with virtual processors.
+        //     3. An existing allocated core will be assigned to the external thread after removing all vprocs that are currently allocated to it.
+        unsigned int externalThreadUseCount = (unsigned int) -1;
+        unsigned int externalThreadCoreIndex = (unsigned int) -1;
+        SchedulerNode * pExternalThreadNode = NULL;
+        unsigned int currentNodeIndex = fSubscribeCurrentThread ? m_pResourceManager->GetCurrentNodeAndCore(NULL) : (unsigned int) -1;
+
+        ASSERT(!fRemoveVProcs || (m_numAllocatedCores > MinHWThreads()));
+
+        unsigned int vprocCount = 0;
+        if (vprocCores > 0)
+        {
+            ASSERT(m_numFullySubscribedCores > 0 && m_numFullySubscribedCores <= m_desiredHardwareThreads);
+            if (vprocCores <= m_numFullySubscribedCores)
+            {
+                vprocCount = vprocCores * m_targetOversubscriptionFactor;
+            }
+            else
+            {
+                vprocCount = (m_numFullySubscribedCores * m_targetOversubscriptionFactor) +
+                                ((vprocCores - m_numFullySubscribedCores) * (m_targetOversubscriptionFactor - 1));
+            }
+        }
+
+        ASSERT(!fInitialAllocation || (vprocCount >= m_minConcurrency && vprocCount <= m_maxConcurrency));
+
+        IVirtualProcessorRoot** vprocArray = (vprocCount > 0) ? _concrt_new IVirtualProcessorRoot *[vprocCount] : NULL;
+        unsigned int vprocIndex = 0;
+        bool externalThreadCoreFound= !fSubscribeCurrentThread;
+
+        // We may not have a core reserved for the external thread, so we should loop until the external thread is assigned to an
+        // existing core, if thread subscription is requested.
+        for (unsigned int nodeIndex = 0; (reservationsAllocated < numberReserved || !externalThreadCoreFound) &&
+                                            nodeIndex < m_nodeCount; ++nodeIndex)
+        {
+            // If the core is marked Reserved, we will either assign to it virtual processors, the external thread or both. Whether or not
+            // the external thread shares the core with virtual processors depends on the value of fShareExternalThreadCore.
+
+            // If we find any cores marked Allocated, it implies that this is not the initial allocation, and all we're looking to do here
+            // is assign a core to the external thread. The external thread could either share a core with vprocs or displace vprocs, depending
+            // on the value of fRemoveVProcs.
+
+            SchedulerNode * pNode = &m_pAllocatedNodes[nodeIndex];
+            if (pNode->m_reservedCores > 0 || pNode->m_allocatedCores > 0)
+            {
+                for(unsigned int coreIndex = 0; (reservationsAllocated < numberReserved || !externalThreadCoreFound) &&
+                                                    coreIndex < pNode->m_coreCount; ++coreIndex)
+                {
+                    SchedulerCore * pCore = &pNode->m_pCores[coreIndex];
+                    if (pCore->m_coreState == ProcessorCore::Reserved)
+                    {
+                        bool assignExternalThread = (!externalThreadCoreFound && (reservationsAllocated == numberReserved - 1 || currentNodeIndex == nodeIndex));
+                        bool assignVProcs = (!assignExternalThread || externalThreadCores == 0);
+
+                        ASSERT(pCore->m_numAssignedThreads == 0 && pCore->m_numFixedThreads == 0);
+                        pCore->m_coreState = ProcessorCore::Allocated;
+                        ASSERT(pNode->m_allocatedCores < pNode->m_coreCount);
+                        ++pNode->m_allocatedCores;
+                        ++m_numAllocatedCores;
+
+                        // If the external thread also needs a core, first try to put it in a node whose affinity is a superset of the hardware thread
+                        // it is currently running on. If not, reaffinitize it.
+                        if (assignExternalThread)
+                        {
+                            // The execution resource is created right before returning from the function.
+                            pExternalThreadNode = pNode;
+                            externalThreadCoreIndex = coreIndex;
+                            externalThreadCoreFound = true;
+                        }
+
+                        if (assignVProcs)
+                        {
+                            ASSERT(!assignExternalThread || fShareExternalThreadCore);
+                            // Create virtual processor roots in the scheduler proxy, corresponding to the node and core we're currently looking at.
+                            unsigned int numVprocs = 0;
+                            if (m_numFullySubscribedCores > 0)
+                            {
+                                numVprocs = m_targetOversubscriptionFactor;
+                                // As we assign m_tof threads to a core, we decrement this value. This value is also updated in
+                                // AddCore and RemoveCore. After the scheduler proxy has been given its initial allocation
+                                // or resources, this variable keeps track of how many out of the remaining quota of cores the
+                                // scheduler proxy could acquire (desired - allocated) would get tof threads per core if they
+                                // were added to the scheduler during dynamic core migration.
+                                --m_numFullySubscribedCores;
+                            }
+                            else
+                            {
+                                numVprocs = m_targetOversubscriptionFactor - 1;
+                            }
+                            pCore->m_numAssignedThreads += numVprocs;
+                            m_numAssignedThreads += numVprocs;
+
+                            while (numVprocs-- > 0)
+                            {
+                                _Analysis_assume_(vprocIndex < vprocCount);
+                                vprocArray[vprocIndex++] = CreateVirtualProcessorRoot(pNode, coreIndex);
+                            }
+                            ASSERT(vprocIndex <= vprocCount);
+                        }
+                        ++reservationsAllocated;
+                    }
+                    else if (pCore->m_coreState == ProcessorCore::Allocated)
+                    {
+                        // If we encounter allocated cores, this is a subsequent allocation for an external core. Determine if the external
+                        // thread should share a core with existing vprocs and external threads, or displace some vprocs to get a core to itself.
+
+                        // Walk through all the allocated cores to find the right one to either oversubscribe or displace. For over
+                        // subscription find the core with the least number of vprocs + external thread assigned to it (favouring the node
+                        // where the current thread is running if there is more than one such core).
+                        // For displacement, we need to find an unfixed core, favouring the node where the current thread is running.
+                        if (fShareExternalThreadCore)
+                        {
+                            ASSERT(!fRemoveVProcs && externalThreadCores == 0);
+
+                            unsigned int useCount = pCore->m_numAssignedThreads + pCore->m_numExternalThreads;
+                            if (useCount < externalThreadUseCount || (useCount == externalThreadUseCount && nodeIndex == currentNodeIndex))
+                            {
+                                externalThreadUseCount = useCount;
+                                pExternalThreadNode = pNode;
+                                externalThreadCoreIndex = coreIndex;
+
+                                // We don't set externalThreadCoreFound here, since we want to examine all allocated cores.
+                            }
+                        }
+                        else if (fRemoveVProcs)
+                        {
+                            ASSERT(externalThreadCores == 1);
+                            if (!pCore->IsFixed() && (pExternalThreadNode == NULL || nodeIndex == currentNodeIndex))
+                            {
+                                pExternalThreadNode = pNode;
+                                externalThreadCoreIndex = coreIndex;
+                                if (nodeIndex == currentNodeIndex)
+                                {
+                                    // Stop looking if we find an unfixed core on the current node.
+                                    externalThreadCoreFound = true;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ASSERT(pCore->m_coreState == ProcessorCore::Unassigned);
+                    }
+                }
+                pNode->m_reservedCores = 0;
+            }
+        }
+
+        ASSERT(vprocIndex == vprocCount);
+        if (vprocCount > 0)
+        {
+            AddVirtualProcessorRoots(vprocArray, vprocCount);
+            delete [] vprocArray;
+        }
+
+        if (fSubscribeCurrentThread)
+        {
+            ASSERT(pExternalThreadNode != NULL && externalThreadCoreIndex != (unsigned int) -1);
+            if (fShareExternalThreadCore)
+            {
+                ASSERT(externalThreadCores == 0);
+            }
+            else if (fRemoveVProcs)
+            {
+                ASSERT(externalThreadCores == 1);
+                ASSERT(m_numAllocatedCores > MinHWThreads());
+                // Remove the core and replace with an external thread subscription. Note that the use count for this core
+                // stays the same, as we simply replace virtual processors with a thread subscription.
+                RemoveCore(pExternalThreadNode, externalThreadCoreIndex);
+
+                pExternalThreadNode->m_pCores[externalThreadCoreIndex].m_coreState = ProcessorCore::Allocated;
+                ASSERT(pExternalThreadNode->m_allocatedCores < pExternalThreadNode->m_coreCount);
+                ++pExternalThreadNode->m_allocatedCores;
+                ++m_numAllocatedCores;
+            }
+            else
+            {
+                ASSERT(externalThreadCores == 1);
+            }
+            pExecutionResource = CreateExternalThreadResource(pExternalThreadNode, externalThreadCoreIndex);
+        }
+#if defined(CONCRT_TRACING)
+        m_numTotalCores = m_nodeCount * m_pAllocatedNodes[0].m_coreCount;
+        m_drmInitialState = _concrt_new SchedulerCoreData[m_numTotalCores];
+        memset(m_drmInitialState, 0, sizeof(SchedulerCoreData) * m_numTotalCores);
+#endif
+        ASSERT(m_numAllocatedCores >= MinHWThreads() && m_numAllocatedCores <= DesiredHWThreads());
+        return pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Causes the resource manager to create a new virtual processor root running atop the same hardware thread as this
+    ///     execution resource. Typically, this is used when a scheduler wishes to oversubscribe a particular hardware thread
+    ///     for a limited amount of time.
+    /// </summary>
+    /// <param name="pExecutionResource">
+    ///     The execution resource abstraction on which to oversubscribe.
+    /// </param>
+    /// <returns>
+    ///     A new virtual processor root running atop the same hardware thread as this execution resource.
+    /// </returns>
+    IVirtualProcessorRoot * SchedulerProxy::CreateOversubscriber(IExecutionResource * pExecutionResource)
+    {
+        // The scheduler proxy on the virtual processor root has to match 'this'
+        VirtualProcessorRoot * pOversubscribedRoot = NULL;
+        ExecutionResource * pResource = dynamic_cast<ExecutionResource *>(pExecutionResource);
+        bool isVprocRoot = false;
+
+        // If dynamic cast failed then we must have a virtual processor root.
+        if (pResource == NULL)
+        {
+            pResource = static_cast<VirtualProcessorRoot *>(pExecutionResource)->GetExecutionResource();
+            isVprocRoot = true;
+        }
+
+        // Cannot verify the scheduler proxy for external threads because they can "live" on
+        // multiple schedulers at the same time (nested).
+        if (isVprocRoot && pResource->GetSchedulerProxy() != this)
+        {
+            throw std::invalid_argument("pExecutionResource");
+        }
+
+        // Synchronize with other concurrent calls that are adding/removing virtual processor roots.
+        {
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            // Use the scheduler proxy to clone this virtual processor root.
+            SchedulerNode * pNode = &m_pAllocatedNodes[pResource->GetNodeId()];
+            unsigned int coreIndex = pResource->GetCoreIndex();
+
+            pOversubscribedRoot = CreateVirtualProcessorRoot(pNode, coreIndex);
+
+            // We mark these vproc roots as oversubscribed to indicate that they do not contribute
+            // towards concurrency levels bounded by the policy
+            pOversubscribedRoot->MarkAsOversubscribed();
+            pNode->m_pCores[coreIndex].m_resources.AddTail(pOversubscribedRoot->GetExecutionResource());
+        }
+
+        return pOversubscribedRoot;
+    }
+
+    /// <summary>
+    ///     Creates a virtual processor root and adds it to the scheduler proxys list of roots.
+    /// </summary>
+    VirtualProcessorRoot * SchedulerProxy::CreateVirtualProcessorRoot(SchedulerNode * pNode, unsigned int coreIndex)
+    {
+        return _concrt_new FreeVirtualProcessorRoot(this, pNode, coreIndex);
+    }
+
+    /// <summary>
+    ///     Notifies the scheduler associated with this proxy to adds the virtual processor roots provided.
+    ///     Called by the RM during initial allocation and dynamic core migration.
+    /// </summary>
+    void SchedulerProxy::AddVirtualProcessorRoots(IVirtualProcessorRoot ** vprocRoots, unsigned int count)
+    {
+        // Note, that we are holding the global RM allocation lock when this API is called.
+        {
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            for (unsigned int i = 0; i < count; ++i)
+            {
+                VirtualProcessorRoot * pRoot = static_cast<VirtualProcessorRoot *>(vprocRoots[i]);
+                // Add the resources associated with the roots to the corresponding lists in the scheduler proxy.
+                unsigned int nodeId = pRoot->GetNodeId();
+                unsigned int coreIndex = pRoot->GetCoreIndex();
+
+                m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_resources.AddTail(pRoot->GetExecutionResource());
+            }
+            m_pScheduler->AddVirtualProcessors((IVirtualProcessorRoot **) vprocRoots, count);
+
+            m_currentConcurrency += count;
+        }
+    }
+
+    /// <summary>
+    ///     Adds an execution resource to the list of resources that run on a particular core.
+    /// </summary>
+    void SchedulerProxy::AddExecutionResource(ExecutionResource * pExecutionResource)
+    {
+        {
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+
+            // Add the resource to the corresponding list in the scheduler proxy.
+            unsigned int nodeId = pExecutionResource->GetNodeId();
+            unsigned int coreIndex = pExecutionResource->GetCoreIndex();
+
+            m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_resources.AddTail(pExecutionResource);
+        }
+    }
+
+    /// <summary>
+    ///     Toggles the state on a core from borrowed to owned (and vice versa), and updates necessary counts.
+    /// </summary>
+    void SchedulerProxy::ToggleBorrowedState(SchedulerNode * pNode, unsigned int coreIndex)
+    {
+        SchedulerCore * pCore = &pNode->m_pCores[coreIndex];
+
+        if (pCore->m_fBorrowed)
+        {
+            --m_numBorrowedCores;
+            --pNode->m_numBorrowedCores;
+            pCore->m_fBorrowed = false;
+        }
+        else
+        {
+            ++m_numBorrowedCores;
+            ++pNode->m_numBorrowedCores;
+            pCore->m_fBorrowed = true;
+        }
+    }
+
+    /// <summary>
+    ///     Adds an appropriate number of virtual processor roots to the scheduler associated with this proxy.
+    ///     Called by the RM during core migration when the RM decides to give this scheduler an additional
+    ///     core.
+    /// </summary>
+    void SchedulerProxy::AddCore(SchedulerNode * pNode, unsigned int coreIndex, bool fBorrowed)
+    {
+        // Note, that we are holding the global RM allocation lock when this API is called.
+
+        // Decide how many virtual processors to give the scheduler on this core. Note that this value is required
+        // to be either m_tof or m_tof - 1.
+
+        unsigned int numThreads = 0;
+        if (m_numFullySubscribedCores > 0)
+        {
+            numThreads = m_targetOversubscriptionFactor;
+            --m_numFullySubscribedCores;
+        }
+        else
+        {
+            numThreads = m_targetOversubscriptionFactor - 1;
+        }
+
+        ASSERT(numThreads > 0 && numThreads <= INT_MAX);
+
+        ASSERT(pNode->m_allocatedCores < pNode->m_coreCount);
+        ++pNode->m_allocatedCores;
+        ASSERT(m_numAllocatedCores < DesiredHWThreads());
+        ++m_numAllocatedCores;
+
+        SchedulerCore * pCore = &pNode->m_pCores[coreIndex];
+
+        ASSERT(pCore->m_coreState == ProcessorCore::Unassigned);
+        pCore->m_coreState = ProcessorCore::Allocated;
+
+        ASSERT(pCore->m_numAssignedThreads == 0);
+        pCore->m_numAssignedThreads = numThreads;
+        m_numAssignedThreads += pCore->m_numAssignedThreads;
+        ASSERT(m_numAssignedThreads <= m_maxConcurrency);
+
+        if (fBorrowed)
+        {
+            ASSERT(!pCore->IsBorrowed());
+            ToggleBorrowedState(pNode, coreIndex);
+        }
+
+        // Special case for when there is 1 vproc per core - this is likely to be the common case.
+        IVirtualProcessorRoot * pRoot;
+        IVirtualProcessorRoot ** pRootArray = (numThreads == 1) ? &pRoot : _concrt_new IVirtualProcessorRoot *[numThreads];
+
+        for (unsigned int i = 0; i < numThreads; ++i)
+        {
+            pRootArray[i] = CreateVirtualProcessorRoot(pNode, coreIndex);
+        }
+
+        AddVirtualProcessorRoots(pRootArray, numThreads);
+
+        if (pRootArray != &pRoot)
+        {
+            delete [] pRootArray;
+        }
+    }
+
+    /// <summary>
+    ///     Notifies the scheduler associated with this proxy to remove the virtual processor roots associated
+    ///     with the core provided. Called by the RM during core migration.
+    /// </summary>
+    void SchedulerProxy::RemoveCore(SchedulerNode * pNode, unsigned int coreIndex)
+    {
+        // Note, that we are holding the global RM allocation lock when this API is called.
+        ASSERT(pNode->m_allocatedCores > 0 && pNode->m_allocatedCores <= pNode->m_coreCount);
+        --pNode->m_allocatedCores;
+        ASSERT(m_numAllocatedCores > MinVprocHWThreads());
+        --m_numAllocatedCores;
+
+        SchedulerCore * pCore = &pNode->m_pCores[coreIndex];
+
+        ASSERT(pCore->m_coreState == ProcessorCore::Allocated || pCore->m_coreState == ProcessorCore::Stolen);
+        pCore->m_coreState = ProcessorCore::Unassigned;
+
+        ASSERT(pCore->m_numAssignedThreads == m_targetOversubscriptionFactor ||
+                    pCore->m_numAssignedThreads == m_targetOversubscriptionFactor - 1);
+        if (pCore->m_numAssignedThreads == m_targetOversubscriptionFactor)
+        {
+            ++m_numFullySubscribedCores;
+        }
+
+        m_numAssignedThreads -= pCore->m_numAssignedThreads;
+        ASSERT(m_numAssignedThreads >= m_minConcurrency && m_numAssignedThreads < m_maxConcurrency);
+        pCore->m_numAssignedThreads = 0;
+
+        if (pCore->m_fBorrowed)
+        {
+            ToggleBorrowedState(pNode, coreIndex);
+        }
+
+        pCore->m_fIdleDuringDRM = false;
+
+        ASSERT(GetNumOwnedCores() >= MinHWThreads());
+
+        // A lock is required around the iteration of nodes and the call to AddVirtualProcessors to synchronize with concurrent
+        // calls to DestroyVirtualProcessorRoot, which removes roots from the array and deletes them.
+
+        { // begin locked region
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            ExecutionResource * pExecutionResource = pCore->m_resources.First();
+            while (pExecutionResource != NULL)
+            {
+                // Remember the next root before hand, since a IVirtualProcessorRoot::Remove call could happen inline
+                // for the root we're removing, and by the time we get back, that root could be deleted.
+                ExecutionResource * pNextExecutionResource = pCore->m_resources.Next(pExecutionResource);
+                VirtualProcessorRoot * pVPRoot = pExecutionResource->GetVirtualProcessorRoot();
+                if (pVPRoot != NULL && !pVPRoot->IsRootRemoved())
+                {
+                    pVPRoot->MarkRootRemoved();
+                    IVirtualProcessorRoot * pIRoot = pVPRoot;
+                    m_pScheduler->RemoveVirtualProcessors(&pIRoot, 1);
+                }
+                pExecutionResource = pNextExecutionResource;
+            }
+        } // end locked region
+    }
+
+    /// <summary>
+    ///     Called by the RM to instruct this scheduler proxy to notify its scheduler that this core is now
+    ///     externally busy or externally idle.
+    /// </summary>
+    void SchedulerProxy::SendCoreNotification(SchedulerCore * pCore, bool isBusyNotification)
+    {
+        // Avoid a memory allocation under two locks if we have less than 8 roots per core - this is expected to be
+        // the common case.
+        IVirtualProcessorRoot * pRootArray[8];
+        IVirtualProcessorRoot ** pRoots= NULL;
+
+#pragma warning(push)
+#pragma warning(disable: 6385 6386) // TRANSITION, VSO-1807030
+        // Note, that we are holding the global RM allocation lock when this API is called.
+        { // begin locked region
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            unsigned int numThreadsIndex = 0;
+
+            if (pCore->m_resources.Count() > 8)
+            {
+                pRoots = _concrt_new IVirtualProcessorRoot * [pCore->m_resources.Count()];
+            }
+            else
+            {
+                pRoots = pRootArray;
+            }
+
+            ExecutionResource * pExecutionResource = pCore->m_resources.First();
+            while (pExecutionResource != NULL)
+            {
+                ExecutionResource * pNextExecutionResource = pCore->m_resources.Next(pExecutionResource);
+                VirtualProcessorRoot * pVPRoot = pExecutionResource->GetVirtualProcessorRoot();
+                if (pVPRoot != NULL && !pVPRoot->IsRootRemoved())
+                {
+                    pRoots[numThreadsIndex++] = pVPRoot;
+                }
+                pExecutionResource = pNextExecutionResource;
+            }
+            ASSERT(numThreadsIndex <= (unsigned int) pCore->m_resources.Count());
+
+            // Now that the array is populated, send notifications for this core
+            if (isBusyNotification)
+            {
+                m_pScheduler->NotifyResourcesExternallyBusy(pRoots, numThreadsIndex);
+            }
+            else
+            {
+                m_pScheduler->NotifyResourcesExternallyIdle(pRoots, numThreadsIndex);
+            }
+
+        } // end locked region
+#pragma warning(pop)
+
+        if (pRoots!= pRootArray)
+        {
+            delete [] pRoots;
+        }
+    }
+    /// <summary>
+    ///     Removes a root from the scheduler proxy and destroys it. This API is called in response to a scheduler
+    ///     informing the RM that it is done with a virtual processor root.
+    /// </summary>
+    void SchedulerProxy::DestroyVirtualProcessorRoot(VirtualProcessorRoot * pRoot)
+    {
+        // Synchronize with other concurrent calls that are adding/removing virtual processor roots.
+        { // begin locked region
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            SchedulerNode * pNode = &m_pAllocatedNodes[pRoot->GetNodeId()];
+            ASSERT(pNode->m_id == pRoot->GetNodeId());
+
+            // NOTE: This API is called in response to a scheduler being done with a virtual processor root.
+            // The scheduler is expected not to invoke ISchedulerProxy::Shutdown, which destroys
+            // all remaining roots in the proxy, until all individual calls for removing virtual processor
+            // roots have completed.
+
+            pNode->m_pCores[pRoot->GetCoreIndex()].m_resources.Remove(pRoot->GetExecutionResource());
+
+            if (!pRoot->IsOversubscribed())
+            {
+                // Oversubscribed vprocs do not contribute towards concurrency level
+                ASSERT(m_currentConcurrency > 0);
+                --m_currentConcurrency;
+            }
+
+        } // end locked region
+
+        pRoot->DeleteThis();
+    }
+
+    /// <summary>
+    ///     Removes an execution resource from the scheduler proxy, and destroys it. This API is called in response to a scheduler
+    ///     informing the RM that it is done with an execution resource.
+    /// </summary>
+    void SchedulerProxy::DestroyExecutionResource(ExecutionResource * pExecutionResource)
+    {
+        // NOTE: This function should be called with the RM lock held.
+        SchedulerNode * pNode = &m_pAllocatedNodes[pExecutionResource->GetNodeId()];
+        SchedulerCore * pCore = &pNode->m_pCores[pExecutionResource->GetCoreIndex()];
+        ASSERT(pNode->m_id == pExecutionResource->GetNodeId());
+
+        // Mark this core as available to others if this was the last resource on it
+        // If this is the last running resource on this core then mark it as available again
+        if (pCore->m_numAssignedThreads + pCore->m_numExternalThreads == 0)
+        {
+            // If there are no vprocs or external threads, then core cannot be fixed
+            ASSERT(!pCore->IsFixed());
+            ASSERT(pNode->m_allocatedCores > 0 && pNode->m_allocatedCores <= pNode->m_coreCount);
+            pNode->m_allocatedCores--;
+            ASSERT(m_numAllocatedCores > MinHWThreads());
+            pCore->m_coreState = ProcessorCore::Unassigned;
+            m_numAllocatedCores--;
+            ASSERT(m_numAllocatedCores <= DesiredHWThreads());
+            m_pResourceManager->DecrementCoreUseCount(pExecutionResource->GetNodeId(), pExecutionResource->GetCoreIndex());
+        }
+
+        // Synchronize with other concurrent calls that are adding/removing execution resources.
+        { // begin locked region
+            _ReentrantBlockingLock::_Scoped_lock lock(m_lock);
+            pCore->m_resources.Remove(pExecutionResource);
+        } // end locked region
+
+        delete pExecutionResource;
+    }
+
+    /// <summary>
+    ///     Called to assist dynamic resource management in determining whether cores assigned to schedulers
+    ///     are idle. An idle core is one whose subscription level is 0.
+    /// </summary>
+    void SchedulerProxy::IncrementCoreSubscription(ExecutionResource * pExecutionResource)
+    {
+        unsigned int nodeId = pExecutionResource->GetNodeId();
+        unsigned int coreIndex = pExecutionResource->GetCoreIndex();
+
+        if ((InterlockedIncrement(&m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_subscriptionLevel) == 1) &&
+            (m_pResourceManager->GetNumSchedulersForNotifications() > (ShouldReceiveNotifications() ? 1UL : 0UL)))
+        {
+            // We've incremented the local subscription from 0 to 1 -> this may warrant notifications.
+            // Note that the number of schedulers needing notifications may change right after we read it, but any
+            // missed notifications will be sent at the next Dynamic RM Poll.
+
+            // We simply set the dynamic RM event here. Note -> there may not yet be a dynamic RM thread at this point.
+            // We clearly have 2 schedulers, but it could be that the second one is just being created. In that case,
+            // notifications will be sent when the dynamic RM starts up (right after the second scheduler has finished
+            // receiving all its resources). We may even race with shutdown for the penultimate scheduler. If the DRM
+            // thread wakes up and there is only one scheduler left, it will go back to waiting.
+            m_pResourceManager->WakeupDynamicRMWorker();
+        }
+    }
+
+    /// <summary>
+    ///     Called to assist dynamic resource management in determining whether cores assigned to schedulers
+    ///     are idle. An idle core is one whose subscription level is 0.
+    /// </summary>
+    void SchedulerProxy::DecrementCoreSubscription(ExecutionResource * pExecutionResource)
+    {
+        unsigned int nodeId = pExecutionResource->GetNodeId();
+        unsigned int coreIndex = pExecutionResource->GetCoreIndex();
+
+        if ((InterlockedDecrement(&m_pAllocatedNodes[nodeId].m_pCores[coreIndex].m_subscriptionLevel) == 0) &&
+            (m_pResourceManager->GetNumSchedulersForNotifications() > (ShouldReceiveNotifications() ? 1UL : 0UL)))
+        {
+            // We've decremented the local subscription from 1 to 0 -> this may warrant notifications.
+            // Note that the number of schedulers needing notifications may change right after we read it, but any
+            // missed notifications will be sent at the next Dynamic RM Poll.
+
+            // We simply set the dynamic RM event here. Note -> there may not yet be a dynamic RM thread at this point.
+            // We clearly have 2 schedulers, but it could be that the second one is just being created. In that case,
+            // notifications will be sent when the dynamic RM starts up (right after the second scheduler has finished
+            // receiving all its resources). We may even race with shutdown for the penultimate scheduler. If the DRM
+            // thread wakes up and there is only one scheduler left, it will go back to waiting.
+            m_pResourceManager->WakeupDynamicRMWorker();
+        }
+    }
+
+    /// <summary>
+    ///     Called to adjust the suggested allocation such that we do not exceed maxConcurrency.
+    ///     This routine takes into account vprocs that are marked for removal but haven't yet been
+    ///     retired by the scheduler. The suggested allocation would be decreased to account for such
+    ///     vprocs.
+    /// </summary>
+    unsigned int SchedulerProxy::AdjustAllocationIncrease(unsigned int suggestedAllocation) const
+    {
+        ASSERT(suggestedAllocation >= GetNumAllocatedCores());
+        ASSERT(suggestedAllocation <= DesiredHWThreads());
+
+        // Figure out the max number of new cores we can add
+        unsigned int newCores = 0;
+
+        // Since we could be not holding the scheduler proxy lock the value in m_currentConcurrency could
+        // be changing. This is fine since a later DRM sweep will migrate appropriate number of cores.
+        if (m_maxConcurrency > m_currentConcurrency)
+        {
+            unsigned int remainingConcurrency = m_maxConcurrency - m_currentConcurrency;
+
+            // Convert remaining concurrency to number of cores
+            unsigned int fullySubscribedConcurrency = m_numFullySubscribedCores * m_targetOversubscriptionFactor;
+
+            if (fullySubscribedConcurrency >= remainingConcurrency)
+            {
+                newCores = remainingConcurrency / m_targetOversubscriptionFactor;
+            }
+            else
+            {
+                ASSERT(m_targetOversubscriptionFactor > 1);
+                newCores = m_numFullySubscribedCores;
+                newCores += ((remainingConcurrency - fullySubscribedConcurrency) / (m_targetOversubscriptionFactor - 1));
+            }
+        }
+
+        unsigned int maxAllocation = (GetNumAllocatedCores() + newCores);
+
+        // Cores used exclusively by external threads are included in numAllocatedCores. As a result
+        // maxAllocation could go above desired.
+        maxAllocation = min(maxAllocation, DesiredHWThreads());
+
+#if defined(CONCRT_TRACING)
+        if (maxAllocation < suggestedAllocation)
+        {
+            TRACE(CONCRT_TRACE_DYNAMIC_RM, L"Scheduler %d: Allocated: %d, Suggested: %d, Adjusted Suggested: %d",
+                GetId(), GetNumAllocatedCores(), suggestedAllocation, maxAllocation);
+        }
+#endif
+
+        return min(maxAllocation, suggestedAllocation);
+    }
+
+    SchedulerProxy::~SchedulerProxy()
+    {
+        //
+        // Clean up anything which might be used during the asynchronous delete.
+        //
+        m_pResourceManager->DestroyAllocatedNodeData(m_pAllocatedNodes);
+        delete [] m_pSortedNodeOrder;
+
+#if defined(CONCRT_TRACING)
+        delete [] m_drmInitialState;
+#endif
+        //
+        // Release the reference on the Resource manager
+        //
+        m_pResourceManager->Release();
+    }
+
+    /// <summary>
+    ///     Called to shutdown a scheduler proxy.  Derived classes can override shutdown behavior based on this.
+    /// </summary>
+    void SchedulerProxy::FinalShutdown()
+    {
+        Cleanup();
+        DeleteThis();
+    }
+
+    /// <summary>
+    ///     Cleans up resources associated with the scheduler.
+    /// </summary>
+    void SchedulerProxy::Cleanup()
+    {
+        //
+        // Delete vproc roots that exist in the allocated nodes at this time.  The deletion here is a notification.  It may happen asynchronously
+        // depending on the type of scheduler proxy.  The data structures maintained for the scheduler proxy cannot go away until the deferred
+        // deletion happens.
+        //
+        for (unsigned int i = 0; i < m_nodeCount; ++i)
+        {
+            SchedulerNode * pNode = &m_pAllocatedNodes[i];
+
+            for (unsigned int j = 0; j < pNode->m_coreCount; ++j)
+            {
+                ExecutionResource * pExecutionResource = pNode->m_pCores[j].m_resources.First();
+
+                while (pExecutionResource != NULL)
+                {
+                    ExecutionResource * pExecutionResourceToDelete = pExecutionResource;
+                    pExecutionResource = pNode->m_pCores[j].m_resources.Next(pExecutionResource);
+                    VirtualProcessorRoot * pVPRoot = pExecutionResourceToDelete->GetVirtualProcessorRoot();
+                    ASSERT(pVPRoot != NULL);
+
+                    // Since the root is going away, check if it contributes to the subscription count on the core, and
+                    // fix up the count, if so.
+                    pVPRoot->ResetSubscriptionLevel();
+                    pVPRoot->DeleteThis();
+                }
+            }
+        }
+
+        delete m_pHillClimbing;
+    }
+
+#if defined(CONCRT_TRACING)
+
+    /// <summary>
+    ///     Sets or clears a flag indicating that the RM needs to do an external thread allocation for this
+    ///     scheduler proxy.
+    /// </summary>
+    void SchedulerProxy::TraceInitialDRMState()
+    {
+        int traceCoreIndex = 0;
+        for (unsigned int nodeIndex = 0; nodeIndex < m_nodeCount; ++nodeIndex)
+        {
+            SchedulerNode * pAllocatedNode = &m_pAllocatedNodes[nodeIndex];
+            for (unsigned int coreIndex = 0; coreIndex < pAllocatedNode->m_coreCount; ++coreIndex)
+            {
+                SchedulerCore * pAllocatedCore = &pAllocatedNode->m_pCores[coreIndex];
+                SchedulerCoreData * pCoreData = &m_drmInitialState[traceCoreIndex++];
+                pCoreData->m_nodeIndex = (unsigned char)nodeIndex;
+                pCoreData->m_coreIndex = (unsigned char)coreIndex;
+                pCoreData->m_fAllocated = pAllocatedCore->m_coreState == ProcessorCore::Allocated;
+                pCoreData->m_fFixed = pAllocatedCore->IsFixed();
+                pCoreData->m_fBorrowed = pAllocatedCore->IsBorrowed();
+                pCoreData->m_fIdle = pAllocatedCore->IsIdle();
+            }
+        }
+    }
+
+#endif
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulerProxy.h

@@ -0,0 +1,647 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulerProxy.h
+//
+// RM proxy for a scheduler instance
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    #pragma warning(push)
+    #pragma warning(disable: 4265) // non-virtual destructor in base class
+    class SchedulerProxy : public ::Concurrency::ISchedulerProxy
+    {
+    public:
+        /// <summary>
+        ///     Constructs a scheduler proxy.
+        /// </summary>
+        SchedulerProxy(IScheduler * pScheduler, ResourceManager * pResourceManager, const SchedulerPolicy &policy);
+
+        /// <summary>
+        ///     Called in order to notify the resource manager that the given scheduler is shutting down.  This
+        ///     will cause the resource manager to immediately reclaim all resources granted to the scheduler.
+        /// </summary>
+        virtual void Shutdown();
+
+        /// <summary>
+        ///     Called by a scheduler in order make an initial request for an allocation of virtual processors.  The request
+        ///     is driven by policies within the scheduler queried via the IScheduler::GetPolicy method.  If the request
+        ///     can be satisfied via the rules of allocation, it is communicated to the scheduler as a call to
+        ///     IScheduler::AddVirtualProcessors.
+        /// </summary>
+        /// <param name="doSubscribeCurrentThread">
+        ///     Whether to subscribe the current thread and account for it during resource allocation.
+        /// </param>
+        /// <returns>
+        ///     The IExecutionResource instance representing current thread if doSubscribeCurrentThread was true; NULL otherwise.
+        /// </returns>
+        virtual IExecutionResource * RequestInitialVirtualProcessors(bool doSubscribeCurrentThread);
+
+        /// <summary>
+        ///     Ensures that a context is bound to a thread proxy.  This API should *NOT* be called in the vast majority of circumstances.
+        ///     The IThreadProxy::SwitchTo will perform late binding to thread proxies as necessary.  There are, however, circumstances
+        ///     where it is necessary to pre-bind a context to ensure that the SwitchTo operation switches to an already bound context.  This
+        ///     is the case on a UMS scheduling context as it cannot call allocation APIs.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context to bind.
+        /// </param>
+        virtual void BindContext(IExecutionContext * pContext);
+
+        /// <summary>
+        ///     Returns an **unstarted** thread proxy attached to pContext, to the thread proxy factory.
+        ///     Such a thread proxy **must** be unstarted.
+        ///     This API should *NOT* be called in the vast majority of circumstances.
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context to unbind.
+        /// </param>
+        virtual void UnbindContext(IExecutionContext * pContext);
+
+        /// <summary>
+        ///     This API registers the current thread with the resource manager associating it with this scheduler,
+        ///     and returns an instance of IExecutionResource back to the scheduler, for bookkeeping and maintenance.
+        /// </summary>
+        /// <returns>
+        ///     The IExecutionResource instance representing current thread in the runtime.
+        /// </returns>
+        virtual IExecutionResource * SubscribeCurrentThread();
+
+        /// <summary>
+        ///     The unique identifier of the scheduler this proxy represents.
+        /// </summary>
+        unsigned int GetId() const
+        {
+            return m_id;
+        }
+
+        /// <summary>
+        ///     Causes the resource manager to create a new virtual processor root running atop the same hardware thread as this
+        ///     execution resource. Typically, this is used when a scheduler wishes to oversubscribe a particular hardware thread
+        ///     for a limited amount of time.
+        /// </summary>
+        /// <param name="pExecutionResource">
+        ///     The execution resource abstraction on which to oversubscribe.
+        /// </param>
+        /// <returns>
+        ///     A new virtual processor root running atop the same hardware thread as this execution resource.
+        /// </returns>
+        virtual IVirtualProcessorRoot * CreateOversubscriber(IExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Getters for the various policy elements.
+        /// </summary>
+        unsigned int MaxConcurrency() const
+        {
+            return m_maxConcurrency;
+        }
+        unsigned int MinConcurrency() const
+        {
+            return m_minConcurrency;
+        }
+        unsigned int TargetOversubscriptionFactor() const
+        {
+            return m_targetOversubscriptionFactor;
+        }
+        int ContextStackSize () const
+        {
+            return m_contextStackSize;
+        }
+        int ContextPriority () const
+        {
+            return m_contextPriority;
+        }
+
+        /// <summary>
+        ///     Returns the minimum number of cores that must contain vprocs for this scheduler. These cores
+        ///     may contain a subscribed thread in addition to virtual processors.
+        /// </summary>
+        unsigned int MinVprocHWThreads() const
+        {
+            // Compute number of cores used for virtual processors that are fixed
+            ASSERT(m_numFixedCores >= m_numExternalThreadCores);
+            unsigned int fixedVprocCores = m_numFixedCores - m_numExternalThreadCores;
+            // Compute maximum(t1, minimum set by policy) which is minimum of virtual processor cores
+            return max(fixedVprocCores, m_minimumHardwareThreads);
+        }
+
+        unsigned int MinHWThreads() const
+        {
+            // The minimum needed number of hardware threads (cores) is equal to:
+            //  - minimum needed vproc cores + minimum needed external thread cores
+            unsigned int minimumCores = MinVprocHWThreads() + m_numExternalThreadCores;
+
+            ASSERT(minimumCores <= m_coreCount);
+            return minimumCores;
+        }
+
+        unsigned int DesiredHWThreads() const
+        {
+            unsigned int desiredCores = min(m_coreCount, m_desiredHardwareThreads + m_numExternalThreadCores);
+
+            ASSERT(m_numExternalThreads != 0 || desiredCores == m_desiredHardwareThreads);
+            return desiredCores;
+        }
+
+        unsigned int ComputeMinHWThreadsWithExternalThread() const
+        {
+            unsigned int newMin = min(m_coreCount, MinHWThreads() + 1);
+            return newMin;
+        }
+
+        unsigned int ComputeDesiredHWThreadsWithExternalThread() const
+        {
+            unsigned int newDesired = min(m_coreCount, DesiredHWThreads() + 1);
+            return newDesired;
+        }
+
+        /// <summary>
+        ///     Returns the number of external thread subscriptions
+        /// </summary>
+        unsigned int GetNumNestedThreadSubscriptions()
+        {
+            return m_threadSubscriptions.Count();
+        }
+
+        /// <summary>
+        ///     Called to adjust the suggested allocation such that we do not exceed maxConcurrency.
+        ///     This routine takes into account vprocs that are marked for removal but haven't yet been
+        ///     retired by the scheduler. The suggested allocation would be decreased to account for such
+        ///     vprocs.
+        /// </summary>
+        unsigned int AdjustAllocationIncrease(unsigned int suggestedAllocation) const;
+
+        /// <summary>
+        ///     Returns the number of cores allocated to the proxy at any time.
+        /// </summary>
+        unsigned int GetNumAllocatedCores() const
+        {
+            return m_numAllocatedCores;
+        }
+
+        /// <summary>
+        ///     Returns the number of borrowed cores. These are cores that were oversubscribed and temporarily
+        ///     assigned to this scheduler during dynamic core migration as they were found to be unused
+        ///     by the other scheduler(s) they were assigned to. The reason these cores were oversubscribed
+        ///     instead of migrated was that they contributed to the minimum number of cores on the other
+        ///     scheduler(s) and hence couldn't be taken away.
+        /// </summary>
+        unsigned int GetNumBorrowedCores() const
+        {
+            return m_numBorrowedCores;
+        }
+
+        /// <summary>
+        ///     Returns the number of owned cores. This is the total allocated cores minus the borrowed cores.
+        /// </summary>
+        unsigned int GetNumOwnedCores() const
+        {
+            return m_numAllocatedCores - m_numBorrowedCores;
+        }
+
+        /// <summary>
+        ///     Returns the number of fixed cores - cores that have a subscribed thread on them. These cores may
+        ///     also have vprocs belonging to this scheduler.
+        /// </summary>
+        unsigned int GetNumFixedCores() const
+        {
+            return m_numFixedCores;
+        }
+
+        /// <summary>
+        ///     Toggles the state on a core from borrowed to owned (and vice versa), and updates necessary counts.
+        /// </summary>
+        void ToggleBorrowedState(SchedulerNode * pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Creates a new execution resource for the external thread and registers it with the scheduler proxy.
+        /// </summary>
+        ExecutionResource * CreateExternalThreadResource(SchedulerNode * pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Called by the RM when it is done reserving cores for the scheduler proxy. The scheduler proxy
+        ///     allocates virtual processors or standalone execution resources based on the cores that were allocated
+        ///     to it.
+        /// </summary>
+        ExecutionResource * GrantAllocation(unsigned int numberReserved, bool fInitialAllocation, bool fSubscribeCurrentThread);
+
+        /// <summary>
+        ///     Finds the core allocated by the RM on which a single subscribed external thread should run.
+        /// </summary>
+        ExecutionResource * GrantExternalThreadAllocation(bool doOversubscribeCore);
+
+        /// <summary>
+        ///     Returns a pointer to the copy of allocated nodes that were assigned to the proxy at
+        ///     creation time.
+        /// </summary>
+        SchedulerNode * GetAllocatedNodes() const
+        {
+            return m_pAllocatedNodes;
+        }
+
+        /// <summary>
+        ///     Sets the allocated nodes for the scheduler proxy to the nodes provided.
+        /// </summary>
+        void SetAllocatedNodes(SchedulerNode * pNodes)
+        {
+            ASSERT(m_pAllocatedNodes == NULL && pNodes != NULL);
+            m_pAllocatedNodes = pNodes;
+        }
+        /// <summary>
+        ///     Returns a pointer to the array that holds the sorted order for nodes. This is used by the
+        ///     RM to sort nodes by whatever criteria it chooses.
+        /// </summary>
+        unsigned int * GetSortedNodeOrder() const
+        {
+            return m_pSortedNodeOrder;
+        }
+
+        /// <summary>
+        ///     Returns a pointer to the scheduler associated with the scheduler proxy.
+        /// </summary>
+        IScheduler * Scheduler() const
+        {
+            return m_pScheduler;
+        }
+
+        /// <summary>
+        ///     Returns a pointer to the resource manager associated with the scheduler proxy.
+        /// </summary>
+        ResourceManager * GetResourceManager() const
+        {
+            return m_pResourceManager;
+        }
+
+        /// <summary>
+        ///     Returns a pointer to a data buffer that is used to store static allocation data. The data
+        ///     is populated and manipulated by the RM, but stored in the scheduler proxy for convenience.
+        /// </summary>
+        StaticAllocationData * GetStaticAllocationData()
+        {
+            return &m_staticData;
+        }
+
+        /// <summary>
+        ///     Returns a pointer to a data buffer that is used to store dynamic allocation data. The data
+        ///     is populated and manipulated by the RM, but stored in the scheduler proxy for convenience.
+        /// </summary>
+        DynamicAllocationData * GetDynamicAllocationData()
+        {
+            return &m_dynamicData;
+        }
+
+        /// <summary>
+        ///     Creates a virtual processor root and adds it to the scheduler proxys list of roots.
+        /// </summary>
+        virtual VirtualProcessorRoot * CreateVirtualProcessorRoot(SchedulerNode * pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Notifies the scheduler associated with this proxy to add the virtual processor roots provided.
+        ///     Called by the RM during initial allocation and dynamic core migration.
+        /// </summary>
+        void AddVirtualProcessorRoots(IVirtualProcessorRoot ** vprocRoots, unsigned int count);
+
+        /// <summary>
+        ///     Adds an appropriate number of virtual processor roots to the scheduler associated with this proxy.
+        ///     Called by the RM during core migration when the RM decides to give this scheduler an additional
+        ///     core.
+        /// </summary>
+        void AddCore(SchedulerNode * pNode, unsigned int coreIndex, bool fBorrowed);
+
+        /// <summary>
+        ///     Notifies the scheduler associated with this proxy to remove the virtual processor roots associated
+        ///     with the core provided. Called by the RM during core migration.
+        /// </summary>
+        void RemoveCore(SchedulerNode * pNode, unsigned int coreIndex);
+
+        /// <summary>
+        ///     Called by the RM to instruct this scheduler proxy to notify its scheduler that this core is now
+        ///     externally busy or externally idle.
+        /// </summary>
+        void SendCoreNotification(SchedulerCore * pCore, bool isBusyNotification);
+
+        /// <summary>
+        ///     Removes a root from the scheduler proxy and destroys it. This API is called in response to a scheduler
+        ///     informing the RM that it is done with a virtual processor root.
+        /// </summary>
+        void DestroyVirtualProcessorRoot(VirtualProcessorRoot * pRoot);
+
+        /// <summary>
+        ///     Removes an execution resource from the scheduler proxy and destroys it. This API is called in response to a scheduler
+        ///     informing the RM that it is done with an execution resource.
+        /// </summary>
+        void DestroyExecutionResource(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Returns a hardware affinity for the given node.  Note that a scheduler proxy may only be assigned a subset
+        ///     of cores within a node -> the mask in the affinity reflects this subset.
+        /// </summary>
+        /// <returns>
+        ///     An abstraction of the hardware affinity which can be applied to Win32 objects.
+        /// </returns>
+        HardwareAffinity GetNodeAffinity(unsigned int nodeId)
+        {
+            ASSERT(nodeId < m_nodeCount);
+            ASSERT(m_pAllocatedNodes[nodeId].m_id == nodeId);
+
+            return HardwareAffinity(static_cast<USHORT>(m_pAllocatedNodes[nodeId].m_processorGroup), m_pAllocatedNodes[nodeId].m_nodeAffinity);
+        }
+
+        /// <summary>
+        ///     Adds an execution resource to the list of resources that run on a particular core.
+        /// </summary>
+        void AddExecutionResource(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Adds the execution resource to the list of subscribed threads
+        /// </summary>
+        void AddThreadSubscription(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Removes the execution resource from the list of subscribed threads
+        /// </summary>
+        void RemoveThreadSubscription(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Creates or reuses an execution resource for the thread subscription
+        /// </summary>
+        ExecutionResource * GetResourceForNewSubscription(ExecutionResource * pParentExecutionResource);
+
+        /// <summary>
+        ///     This function retrieves the execution resource associated with this thread, if one exists,
+        ///     and updates the reference count on it for better bookkeeping.
+        /// </summary>
+        /// <returns>
+        ///     The ExecutionResource instance representing current thread in the runtime.
+        /// </returns>
+        ExecutionResource * ReferenceCurrentThreadExecutionResource();
+
+        /// <summary>
+        ///     This function retrieves the execution resource associated with this thread, if one exists.
+        /// </summary>
+        /// <returns>
+        ///     The ExecutionResource instance representing current thread in the runtime.
+        /// </returns>
+        ExecutionResource * GetCurrentThreadExecutionResource();
+
+        /// <summary>
+        ///     Registers that a call to SubscribeCurrentThread has occurred for this core, making this core immovable.
+        /// </summary>
+        void IncrementFixedCoreCount(unsigned int nodeId, unsigned int coreIndex, bool isExternalThread);
+
+        /// <summary>
+        ///     Registers that a call to IExecutionResource::Release has occurred, potentially freeing this core.
+        /// </summary>
+        void DecrementFixedCoreCount(unsigned int nodeId, unsigned int coreIndex, bool isExternalThread);
+
+        /// <summary>
+        ///     Returns the number of external threads on this scheduler proxy.
+        /// </summary>
+        unsigned int GetNumExternalThreads()
+        {
+            return m_numExternalThreads;
+        }
+
+        /// <summary>
+        ///     Decides whether this scheduler proxy should receive notifications when other
+        ///     schedulers borrow its cores or return them back.
+        /// </summary>
+        bool ShouldReceiveNotifications()
+        {
+            return (m_minimumHardwareThreads == m_desiredHardwareThreads);
+        }
+
+        /// <summary>
+        ///     A function that passes statistical information to the hill climbing instance. Based on these
+        ///     statistics, hill climbing will make a recommendation on the number of resources the scheduler
+        ///     should be allocated.
+        /// </summary>
+        /// <param name="currentCoreCount">
+        ///     The number of resources used in this period of time.
+        /// </param>
+        /// <param name="completionRate">
+        ///     The number of completed units or work in that period of time.
+        /// </param>
+        /// <param name="arrivalRate">
+        ///     The number of incoming units or work in that period of time.
+        /// </param>
+        /// <param name="queueLength">
+        ///     The total length of the work queue.
+        /// </param>
+        /// <returns>
+        ///     The recommended allocation for the scheduler.
+        /// </returns>
+        unsigned int DoHillClimbing(unsigned int currentCoreCount, unsigned int completionRate, unsigned int arrivalRate, unsigned int queueLength)
+        {
+            return m_pHillClimbing->Update(currentCoreCount, completionRate, arrivalRate, queueLength);
+        }
+
+        /// <summary>
+        ///     This function returns whether the scheduler has opted in to statistical rebalancing.
+        /// </summary>
+        /// <returns>
+        ///     Whether hill climbing is enabled.
+        /// </returns>
+        bool IsHillClimbingEnabled()
+        {
+            return m_fDoHillClimbing;
+        }
+
+        /// <summary>
+        ///     Gets the current length of the scheduler queue.
+        /// </summary>
+        /// <returns>
+        ///     The queue length.
+        /// </returns>
+        unsigned int GetQueueLength()
+        {
+            return m_queueLength;
+        }
+
+        /// <summary>
+        ///     Sets the current length of the scheduler queue.
+        /// </summary>
+        /// <param name="queueLength">
+        ///     The length to be set.
+        /// </param>
+        void SetQueueLength(unsigned int queueLength)
+        {
+            m_queueLength = queueLength;
+        }
+
+        /// <summary>
+        ///     Gets a new thread proxy from the factory.
+        /// </summary>
+        virtual IThreadProxy * GetNewThreadProxy(IExecutionContext * pContext);
+
+        /// <summary>
+        ///     Called to shutdown a scheduler proxy.  Derived classes can override shutdown behavior based on this.
+        /// </summary>
+        virtual void FinalShutdown();
+
+        /// <summary>
+        ///     Called to assist dynamic resource management in determining whether cores assigned to schedulers
+        ///     are idle. An idle core is one whose subscription level is 0.
+        /// </summary>
+        void IncrementCoreSubscription(ExecutionResource * pExecutionResource);
+
+        /// <summary>
+        ///     Called to assist dynamic resource management in determining whether cores assigned to schedulers
+        ///     are idle. An idle core is one whose subscription level is 0.
+        /// </summary>
+        void DecrementCoreSubscription(ExecutionResource * pExecutionResource);
+
+#if defined(CONCRT_TRACING)
+        /// <summary>
+        ///     Captures the initial state of the scheduler map at the beginning of core migration, each cycle.
+        /// </summary>
+        void TraceInitialDRMState();
+#endif
+
+protected:
+
+        /// <summary>
+        ///     Deletes the scheduler proxy.
+        /// </summary>
+        virtual void DeleteThis()
+        {
+            delete this;
+        }
+
+        /// <summary>
+        ///     Cleans up resources associated with the scheduler.
+        /// </summary>
+        void Cleanup();
+
+        /// <summary>
+        ///     Destructor.
+        /// </summary>
+        ~SchedulerProxy();
+
+        // A cached pointer to a thread proxy factory of the appropriate type for this scheduler proxy.
+        IThreadProxyFactory * m_pThreadProxyFactory;
+
+    private:
+        template <class T, class Counter> friend class List;
+
+#if defined(CONCRT_TRACING)
+
+        struct SchedulerCoreData
+        {
+            unsigned char m_nodeIndex;
+            unsigned char m_coreIndex;
+            bool m_fAllocated : 1;
+            bool m_fFixed : 1;
+            bool m_fBorrowed : 1;
+            bool m_fIdle : 1;
+        };
+
+        // Captures the initial global allocation during the DRM phase.
+        SchedulerCoreData * m_drmInitialState;
+        unsigned int m_numTotalCores;
+
+#endif
+        IScheduler * m_pScheduler;
+
+        // Pointer to the resource manager instance.
+        ResourceManager * m_pResourceManager;
+
+        // Local copy of allocation map for this scheduler proxy.
+        SchedulerNode * m_pAllocatedNodes;
+
+        // Helper array used to sort nodes, used by the RM during core migration.
+        unsigned int * m_pSortedNodeOrder;
+
+        // Links for a list.
+        SchedulerProxy * m_pNext{}, * m_pPrev{};
+
+        // A lock that protects resource allocation and deallocation of roots within this proxy.
+        _ReentrantBlockingLock m_lock;
+
+        // Hill climbing instance.
+        HillClimbing * m_pHillClimbing;
+
+        // Static and dynamic allocation data is populated and manipulated by the RM, but
+        // stored in the scheduler proxy for convenience.
+        union
+        {
+            // Data used during static allocation.
+            StaticAllocationData m_staticData;
+
+            // Data used during dynamic allocation.
+            DynamicAllocationData m_dynamicData;
+        };
+
+        // Scheduler queue length.
+        unsigned int m_queueLength;
+
+        // Unique identifier.
+        unsigned int m_id;
+
+        // Variables that store policy elements.
+        unsigned int m_desiredHardwareThreads;
+        unsigned int m_minimumHardwareThreads;
+        unsigned int m_minConcurrency;
+        unsigned int m_maxConcurrency;
+        unsigned int m_targetOversubscriptionFactor;
+        int m_contextStackSize;
+        int m_contextPriority;
+
+        // Current concurrency level (number of vproc roots). This includes vproc roots
+        // that are marked for removal but has not yet been destroyed by the scheduler.
+        // Protected by the scheduler proxy lock
+        unsigned int m_currentConcurrency;
+
+        // The number of cores allocated to this scheduler proxy.
+        unsigned int m_numAllocatedCores;
+
+        // At any time this has the number of additional cores that can be allocated with m_tof threads.
+        // When this falls to 0, all remaining allocated cores will get m_tof - 1 threads, to ensure that
+        // we don't go over max concurrency threads.
+        unsigned int m_numFullySubscribedCores;
+
+        // The number of allocated cores that are borrowed. An borrowed core is a core that is assigned to
+        // one or more different schedulers, but was found to be idle. The RM temporarily assigns idle resources to
+        // schedulers that need them.
+        unsigned int m_numBorrowedCores;
+
+        // The number of cores that have a subscribed thread on them. These cores are 'fixed' in that they cannot
+        // be removed by static/dynamic allocations, as long as the subscribed thread is present on them.
+        unsigned int m_numFixedCores;
+
+        // The number of virtual processors (threads) that were added to the related scheduler via initial
+        // allocation or core migration. Does not include oversubscribed virtual processors.
+        unsigned int m_numAssignedThreads;
+
+        // The number of external threads that were added to the related scheduler via external subscription calls.
+        unsigned int m_numExternalThreads;
+
+        // The number of cores that external threads occupy exclusively.
+        unsigned int m_numExternalThreadCores;
+
+        // The number of hardware threads available on this machine.
+        unsigned int m_coreCount;
+
+        // Number of nodes in the allocated nodes array.
+        unsigned int m_nodeCount;
+
+        // List of execution resources representing subscribed threads
+        List<ExecutionResource, CollectionTypes::Count> m_threadSubscriptions;
+
+        // Used to determine whether statistical rebalancing is used for this scheduler proxy.
+        bool m_fDoHillClimbing;
+    };
+
+    #pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulingNode.cpp

@@ -0,0 +1,294 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulingNode.cpp
+//
+// Source file containing the SchedulingNode implementation.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    SchedulingNode::SchedulingNode(const QuickBitSet& resourceSet, DWORD numaNodeNumber, SchedulingRing *pRing)
+        : m_pRing(pRing)
+        , m_resourceSet(resourceSet)
+        , m_virtualProcessorAvailableCount(0)
+        , m_virtualProcessorsPendingThreadCreate(0)
+        , m_virtualProcessorCount(0) // needed for scheduling rings
+        , m_ramblingCount(0)
+        , m_numaNodeNumber(numaNodeNumber)
+        , m_virtualProcessors(pRing->m_pScheduler, 256, ListArray<VirtualProcessor>::DeletionThresholdInfinite)
+    {
+        m_pScheduler = m_pRing->m_pScheduler;
+        m_id = m_pRing->Id();
+    }
+
+    SchedulingNode::~SchedulingNode()
+    {
+        Cleanup();
+    }
+
+    void SchedulingNode::Cleanup()
+    {
+        //
+        // Do not clean up m_pRing here, it is done at SchedulerBase::m_rings
+        //
+
+        // Cleanup of the virtual processors does not need to explicitly happen.  When
+        // the destructor of the list array is called, it will internally delete
+        // all of its elements
+    }
+
+    /// <summary>
+    ///     Creates and adds a new virtual processor in the node to associated with the root provided.
+    ///     NOTE: For non-oversubscribed vprocs this API is currently will only work for initial allocation.
+    /// </summary>
+    /// <param name="pOwningRoot">
+    ///     The virtual processor root to create the virtual processor with.
+    /// </param>
+    /// <param name="fOversubscribed">
+    ///     True if this is an oversubscribed virtual processor.
+    /// </param>
+    /// <returns>
+    ///     The newly created virtual processor.
+    /// </returns>
+    VirtualProcessor* SchedulingNode::AddVirtualProcessor(IVirtualProcessorRoot *pOwningRoot, bool fOversubscribed)
+    {
+        ContextBase *pCurrentContext = SchedulerBase::FastCurrentContext();
+
+        // Try and grab a virtual processor from the free pool before creating a new one
+        VirtualProcessor *pVirtualProcessor = m_virtualProcessors.PullFromFreePool();
+        if (pVirtualProcessor == NULL)
+        {
+            pVirtualProcessor = m_pScheduler->CreateVirtualProcessor(this, pOwningRoot);
+        }
+        else
+        {
+            pVirtualProcessor->Initialize(this, pOwningRoot);
+        }
+
+        if (fOversubscribed)
+        {
+            ASSERT(pCurrentContext != NULL && !pCurrentContext->IsExternal());
+            InternalContextBase * pOversubscribingContext = static_cast<InternalContextBase *>(pCurrentContext);
+
+            pVirtualProcessor->m_fOversubscribed = true;
+            pVirtualProcessor->m_pOversubscribingContext = pOversubscribingContext;
+
+            // The oversubscribed vproc is fenced by adding it to the list array below.
+            pOversubscribingContext ->SetOversubscribedVProc(pVirtualProcessor);
+        }
+
+        // We increment the total count of virtual processors on the node since the rambling logic uses this count.
+        InterlockedIncrement(&m_virtualProcessorCount);
+        m_pScheduler->IncrementActiveResourcesByMask(pVirtualProcessor->GetMaskId());
+
+        // If no virtual processors are 'available' in the scheduler, try to start this one up right away, if not, make it available,
+        // and increment the counts to indicate this. The only exception is the first virtual processor added as part of the initial
+        // set of virtual processors.
+        //
+        // @TODO: Q: Is the lack of relative atomicity between the two counts (avail / pending thread) a problem here for any real
+        // scenario?
+        if ((m_pScheduler->m_virtualProcessorAvailableCount == m_pScheduler->m_virtualProcessorsPendingThreadCreate) && (m_pScheduler->m_virtualProcessorCount > 0))
+        {
+            //
+            // The check above is not accurate, since the count may increase right after the check -> in the worst case, the virtual
+            // processor is activated when it should've been left available.
+            //
+            // We should only be activating virtual processors as they are added, if they are either oversubscribed or as a result
+            // of core migration. The initial set of virtual processors should never be activated here.
+            //
+            ASSERT(pCurrentContext == NULL || fOversubscribed);
+
+            //
+            // The vproc should be added to the list array only after it is fully initialized. If this is an oversubscribed vproc,
+            // we need to synchronize with a concurrent RemoveCore, which assumes it can party on the vproc if it is found in the list
+            // array.
+            //
+            m_virtualProcessors.Add(pVirtualProcessor);
+
+            //
+            // Activation of a virtual processor synchronizes with finalization. If the scheduler is in the middle of finalization
+            // or has already shutdown, the API will return false.
+            //
+            bool activated = m_pScheduler->VirtualProcessorActive(true);
+
+            if (activated)
+            {
+                ScheduleGroupSegmentBase * pSegment = (pCurrentContext != NULL) ?
+                                                            pCurrentContext->GetScheduleGroupSegment() :
+                                                            m_pRing->GetAnonymousScheduleGroupSegment();
+                pVirtualProcessor->StartupWorkerContext(pSegment);
+            }
+            else
+            {
+                //
+                // We do nothing here since the scheduler is shutting down/has shutdown. The virtual processor remains unavailable,
+                // and since we didn't increment available counts, we don't have to decrement them.
+                //
+            }
+        }
+        else
+        {
+            //
+            // The vproc should be added to the list array only after it is fully initialized. If this is an oversubscribed vproc,
+            // we need to synchronize with a concurrent RemoveVirtualProcessor, which assumes it can party on the vproc if it is
+            // found in the list array.
+            //
+            m_virtualProcessors.Add(pVirtualProcessor);
+            pVirtualProcessor->MakeAvailable(VirtualProcessor::AvailabilityInactive, false);
+
+            OMTRACE(MTRACE_EVT_MADEAVAILABLE, m_pScheduler, SchedulerBase::FastCurrentContext(), pVirtualProcessor, NULL);
+            OMTRACE(MTRACE_EVT_AVAILABLEVPROCS, m_pScheduler, SchedulerBase::FastCurrentContext(), this, m_pScheduler->m_virtualProcessorAvailableCount);
+        }
+
+        return pVirtualProcessor;
+    }
+
+    /// <summary>
+    ///     Find the virtual processor in this node that matches the root provided.
+    /// </summary>
+    /// <param name="pRoot">
+    ///     The virtual processor root to match.
+    /// </param>
+    /// <remarks>
+    ///     IMPORTANT: This API is only called while removing virtual processors via IScheduler::RemoveVirtualProcessors.
+    ///     If this functionality is needed at other call sites in the future, the implementation may need to be
+    ///     reevaluated (see comments below).
+    /// </remarks>
+    VirtualProcessor* SchedulingNode::FindMatchingVirtualProcessor(IVirtualProcessorRoot* pRoot)
+    {
+        int arraySize = m_virtualProcessors.MaxIndex();
+
+        for (int i = 0; i < arraySize; i++)
+        {
+            VirtualProcessor *pVirtualProcessor = m_virtualProcessors[i];
+
+            // It is ok to test the owning root here without a lock. If the owning root matches what we're looking for,
+            // we are guaranteed it will not change (by way of the virtual processor being retired and reused). This is because
+            // the call to IVirtualProcessorRoot::Remove in the virtual processor retirement code path is serialized in the RM
+            // before or after the call to IScheduler::RemoveVirtualProcessors. i.e. if we find an owning root that matches, the retirement
+            // path is unable to set it to NULL until after we're done.
+            if ((pVirtualProcessor != NULL) && (pVirtualProcessor->m_pOwningRoot == pRoot))
+            {
+                return pVirtualProcessor;
+            }
+        }
+
+        return NULL;
+    }
+
+    InternalContextBase *SchedulingNode::StealLocalRunnableContext(VirtualProcessor* pSkipVirtualProcessor)
+    {
+        InternalContextBase *pContext = NULL;
+        int skipIndex, startIndex;
+        int arraySize = m_virtualProcessors.MaxIndex();
+
+        if (pSkipVirtualProcessor != NULL)
+        {
+            skipIndex = pSkipVirtualProcessor->m_listArrayIndex;
+            startIndex = 1;
+        }
+        else
+        {
+            skipIndex = 0;
+            startIndex = 0;
+        }
+
+        for (int i = startIndex; i < arraySize; i++)
+        {
+            int index = (i + skipIndex) % arraySize;
+            VirtualProcessor *pVirtualProcessor = m_virtualProcessors[index];
+            if (pVirtualProcessor == NULL)
+            {
+                continue;
+            }
+
+            pContext = pVirtualProcessor->m_localRunnableContexts.Steal();
+            if (pContext != NULL)
+            {
+#if defined(_DEBUG)
+                pContext->SetDebugBits(CTX_DEBUGBIT_STOLENFROMLOCALRUNNABLECONTEXTS);
+#endif // _DEBUG
+
+                break;
+            }
+        }
+        return pContext;
+    }
+
+    /// <summary>
+    ///     Find an available virtual processor in the scheduling node. We claim ownership of the virtual
+    ///     processor and return it.
+    /// </summary>
+    bool SchedulingNode::FoundAvailableVirtualProcessor(VirtualProcessor::ClaimTicket& ticket,
+                                                        location bias,
+                                                        ULONG type)
+    {
+        if (bias._GetType() == location::_ExecutionResource)
+        {
+            VirtualProcessor *pBiasProc = FindVirtualProcessorByLocation(&bias);
+            ASSERT(!pBiasProc || pBiasProc->GetOwningNode() == this);
+            if (pBiasProc && pBiasProc->ClaimExclusiveOwnership(ticket, type))
+                return true;
+        }
+
+        // The callers of this API MUST check that that the available virtual processor count in the scheduling node
+        // is non-zero before calling the API. We avoid putting that check here since it would evaluate to false
+        // most of the time, and it saves the function call overhead on fast paths (chore push)
+
+        for (int i = 0; i < m_virtualProcessors.MaxIndex(); i++)
+        {
+            VirtualProcessor *pVirtualProcessor = m_virtualProcessors[i];
+
+             if (pVirtualProcessor != NULL && pVirtualProcessor->ClaimExclusiveOwnership(ticket, type))
+                return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Gets a location object which represents the scheduling node.
+    /// </summary>
+    location SchedulingNode::GetLocation()
+    {
+        return location(location::_SchedulingNode, m_id, m_pScheduler->Id(), this);
+    }
+
+    /// <summary>
+    ///     Returns a virtual processor from the given location.  The virtual processor must be within this node.
+    /// </summary>
+    VirtualProcessor* SchedulingNode::FindVirtualProcessorByLocation(const location* pLoc)
+    {
+        if (pLoc->_GetType() != location::_ExecutionResource)
+            return NULL;
+
+        if (m_pScheduler->IsLocationBound(pLoc))
+            return pLoc->_As<VirtualProcessor>();
+
+        //
+        // The specified location has not been specifically bound yet.  Find any virtual processor which we deem appropriate for the binding
+        // to the specified execution resource id.
+        //
+        for (int i = 0; i < m_virtualProcessors.MaxIndex(); i++)
+        {
+            VirtualProcessor *pVirtualProcessor = m_virtualProcessors[i];
+
+            if (pVirtualProcessor != NULL && pVirtualProcessor->GetExecutionResourceId() == pLoc->_GetId())
+                return pVirtualProcessor;
+        }
+
+        return NULL;
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulingNode.h

@@ -0,0 +1,251 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulingNode.h
+//
+// Source file containing the SchedulingNode declaration.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    /// A scheduling node corresponds to a NUMA node or a processor package; containing one or more virtual processor groups.
+    /// </summary>
+    class SchedulingNode
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a scheduling node.
+        /// </summary>
+        SchedulingNode(const QuickBitSet& resourceSet, DWORD numaNodeNumber, SchedulingRing *pRing);
+
+        /// <summary>
+        ///     Destroys a scheduling node.
+        /// </summary>
+        ~SchedulingNode();
+
+        /// <summary>
+        ///     Creates and adds a new virtual processor in the node to associated with the root provided.
+        ///     NOTE: For non-oversubscribed vprocs this API is currently will only work for initial allocation.
+        /// </summary>
+        /// <param name="pOwningRoot">
+        ///     The virtual processor root to create the virtual processor with.
+        /// </param>
+        /// <param name="fOversubscribed">
+        ///     True if this is an oversubscribed virtual processor.
+        /// </param>
+        /// <returns>
+        ///     The newly created virtual processor.
+        /// </returns>
+        VirtualProcessor* AddVirtualProcessor(IVirtualProcessorRoot *pOwningRoot, bool fOversubscribed = false);
+
+        /// <summary>
+        ///     Returns the scheduler associated with the node.
+        /// </summary>
+        SchedulerBase * GetScheduler() { return m_pScheduler; }
+
+        /// <summary>
+        ///     Returns the scheduling ring associated with the node.
+        /// </summary>
+        SchedulingRing * GetSchedulingRing() { return m_pRing; }
+
+        /// <summary>
+        ///     Find the virtual processor in this node that matches the root provided.
+        /// </summary>
+        /// <param name="pRoot">
+        ///     The virtual processor root to match.
+        /// </param>
+        VirtualProcessor* FindMatchingVirtualProcessor(IVirtualProcessorRoot* pRoot);
+
+        /// <summary>
+        ///     Returns the ID of the scheduling node.
+        /// </summary>
+        int Id() const
+        {
+            return m_id;
+        }
+
+        /// <summary>
+        ///     Returns the first virtual processor in the non-cyclic range [min, max).  If such is found
+        ///     the virtual processor is returned and pIdx contains its index within the list array.
+        ///     If not found, NULL is returned and the value in pIdx is unspecified.
+        /// </summary>
+        VirtualProcessor *FindVirtualProcessor(int min, int max, int *pIdx)
+        {
+            VirtualProcessor *pVProc = NULL;
+            int i = min;
+            for (; i < max && pVProc == NULL; ++i)
+            {
+                pVProc = m_virtualProcessors[i];
+            }
+
+            //
+            // The loop incremented "i" prior to the check.  If found, the index is i - 1.  If not, we care
+            // not what pIdx contains.
+            //
+            *pIdx = i - 1;
+            return pVProc;
+        }
+
+        /// <summary>
+        ///     Returns the first virtual processor.
+        /// </summary>
+        /// <param name="pIdx">
+        ///     The iterator position of the returned virtual processor will be placed here.  This can only be
+        ///     utilized as the pIdx parameter or the idxStart parameter of a GetNextVirtualProcessor.
+        /// </param>
+        VirtualProcessor *GetFirstVirtualProcessor(int *pIdx)
+        {
+            return FindVirtualProcessor(0, m_virtualProcessors.MaxIndex(), pIdx);
+        }
+
+        /// <summary>
+        ///     Returns the next virtual processor in an iteration.
+        /// </summary>
+        VirtualProcessor *GetNextVirtualProcessor(int *pIdx, int idxStart = 0)
+        {
+            VirtualProcessor *pVProc = NULL;
+
+            int min = *pIdx + 1;
+            if (min > idxStart)
+            {
+                pVProc = FindVirtualProcessor(min, m_virtualProcessors.MaxIndex(), pIdx);
+                min = 0;
+            }
+
+            if (pVProc == NULL)
+                pVProc = FindVirtualProcessor(min, idxStart, pIdx);
+
+            return pVProc;
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is available.
+        /// </summary>
+        bool HasVirtualProcessorAvailable() const
+        {
+            return m_virtualProcessorAvailableCount > 0;
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is waiting for throttling.
+        /// </summary>
+        bool HasVirtualProcessorPendingThread() const
+        {
+            return m_virtualProcessorsPendingThreadCreate > 0;
+        }
+
+        /// <summary>
+        ///     Returns whether a virtual processor is available to execute new work.
+        /// </summary>
+        bool HasVirtualProcessorAvailableForNewWork() const
+        {
+            //
+            // The observational race (lack of atomicity between the two reads) should not matter.  If it does in some obscure
+            // case, a new atomic counter can be added.
+            //
+            return (m_virtualProcessorAvailableCount - m_virtualProcessorsPendingThreadCreate) > 0;
+        }
+
+        /// <summary>
+        ///     Gets a location object which represents the scheduling node.
+        /// </summary>
+        location GetLocation();
+
+        /// <summary>
+        ///     Returns a virtual processor from the given location.  The virtual processor must be within this node.
+        /// </summary>
+        VirtualProcessor* FindVirtualProcessorByLocation(const location* pLoc);
+
+        /// <summary>
+        ///     Determines whether the scheduling node contains an execution resource with ID as specified.  Note that this does NOT return
+        ///     whether the said resource is available in the scheduler -- only whether the given resource ID is logically contained in the
+        ///     node.  The scheduler may have no virtual processor with that execution resource ID at the moment.
+        /// </summary>
+        bool ContainsResourceId(unsigned int resourceId) /*const*/
+        {
+            return m_resourceBitMap.Exists(resourceId);
+        }
+
+        /// <summary>
+        ///     Notifies the node of a resource that is contained within it and its assigned position in all bitmasks used by all ConcRT
+        ///     schedulers.
+        /// </summary>
+        void NotifyResource(unsigned int resourceId, unsigned int maskId)
+        {
+            m_resourceBitMap.Insert(resourceId, maskId);
+        }
+
+        /// <summary>
+        ///     Returns the bitset for all resources in the node.
+        /// </summary>
+        const QuickBitSet& GetResourceSet()
+        {
+            return m_resourceSet;
+        }
+
+        /// <summary>
+        ///     Gets the NUMA node to which this scheduling node belongs.
+        /// </summary>
+        DWORD GetNumaNodeNumber() const
+        {
+            return m_numaNodeNumber;
+        }
+
+    private:
+        friend class SchedulerBase;
+        friend class VirtualProcessor;
+        friend class InternalContextBase;
+        friend class FairScheduleGroup;
+        template <typename T> friend class ListArray;
+
+        // Owning scheduler
+        SchedulerBase *m_pScheduler;
+
+        // Owning ring
+        SchedulingRing * const m_pRing;
+
+        // The bit-set identifying execution resources within this node for quick affinity masking.
+        QuickBitSet m_resourceSet;
+
+        // Maps resource IDs contained within the node to a mask identifier
+        Hash<unsigned int, unsigned int> m_resourceBitMap;
+
+        volatile LONG m_virtualProcessorAvailableCount;
+        volatile LONG m_virtualProcessorsPendingThreadCreate;
+
+        volatile LONG m_virtualProcessorCount;
+        volatile LONG m_ramblingCount; // rambling -- searching foreign nodes for work
+
+        DWORD m_numaNodeNumber;
+
+        int m_id;
+
+        // Virtual processors owned by this node.
+        ListArray<VirtualProcessor> m_virtualProcessors;
+
+        InternalContextBase *StealLocalRunnableContext(VirtualProcessor* pSkipVirtualProcessor = NULL);
+
+        /// <summary>
+        ///     Find an available virtual processor in the scheduling node.
+        /// </summary>
+        bool FoundAvailableVirtualProcessor(VirtualProcessor::ClaimTicket& ticket,
+                                            location bias = location(),
+                                            ULONG type = VirtualProcessor::AvailabilityAny);
+
+        void Cleanup();
+
+        // Prevent warning about generated assignment operator & copy constructors.
+        SchedulingNode(const SchedulingNode&);
+        void operator=(const SchedulingNode&);
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulingRing.cpp

@@ -0,0 +1,73 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulingRing.cpp
+//
+// Source file containing the SchedulingRing implementation.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Construct a new scheduling ring.
+    /// </summary>
+    SchedulingRing::SchedulingRing(SchedulerBase *pScheduler, int id)
+        : m_pScheduler(pScheduler)
+        , m_pNode(NULL) // Will be set later explicitly by the creating scheduler
+        , m_pAnonymousSegment(NULL)
+        , m_affineSegments(pScheduler, 256, 64)
+        , m_nonAffineSegments(pScheduler, 256, 64)
+        , m_nextAffineSegment(0)
+        , m_nextNonAffineSegment(0)
+        , m_id(id)
+        , m_active(0)
+    {
+        //
+        // Create the anonymous schedule group early.  UMS schedulers need somewhere to begin a search for a given node that is guaranteed
+        // to be safe.  This is the only such place.
+        //
+        // Create schedule group takes a reference to the schedule group. The scheduling
+        // node maintains this reference and will release it when it disassociates from the
+        // schedule group (either in the destructor, or if the schedule group is moved to
+        // a different node due to resource management reclaiming the node).
+        //
+        location unbiased;
+        m_pAnonymousSegment = pScheduler->GetAnonymousScheduleGroup()->CreateSegment(&unbiased, this);
+    }
+
+    SchedulingRing::~SchedulingRing()
+    {
+        ASSERT(m_pAnonymousSegment != NULL);
+        m_pAnonymousSegment = NULL;
+    }
+
+    //
+    // Called when a schedule group's ref count is 0. remove this schedule group from the action.
+    //
+    void SchedulingRing::RemoveScheduleGroupSegment(ScheduleGroupSegmentBase *pSegment)
+    {
+        if (pSegment->GetAffinity()._Is_system())
+            m_nonAffineSegments.Remove(pSegment);
+        else
+            m_affineSegments.Remove(pSegment);
+    }
+
+    /// <summary>
+    ///     Activates the ring.
+    /// </summary>
+    void SchedulingRing::Activate()
+    {
+        InterlockedExchange(&m_active, 1);
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SchedulingRing.h

@@ -0,0 +1,255 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SchedulingRing.h
+//
+// Source file containing the SchedulingRing declaration.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     A scheduling node corresponds to a NUMA node or a processor package; containing one or more virtual processor groups.
+    /// </summary>
+    class SchedulingRing
+    {
+    public:
+        SchedulingRing(SchedulerBase *pScheduler, int id);
+
+        ~SchedulingRing();
+
+        int Id() const
+        {
+            return m_id;
+        }
+
+        // Create a new Schedule Group
+        ScheduleGroupBase *AllocateScheduleGroup();
+
+        // Delete a Schedule Group
+        void FreeScheduleGroup(ScheduleGroupBase *pGroup);
+
+        // Create a schedule group, add it to the list of groups
+        ScheduleGroupBase *CreateScheduleGroup();
+
+        ScheduleGroupSegmentBase *GetAnonymousScheduleGroupSegment() const
+        {
+            return m_pAnonymousSegment;
+        }
+
+        /// <summary>
+        ///     Returns a shared index to pseudo-round robin through affine schedule group segments within the ring.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetPseudoRRAffineScheduleGroupSegment(int *pIdx)
+        {
+            int min = m_nextAffineSegment;
+
+            ScheduleGroupSegmentBase *pSegment = FindScheduleGroupSegment(min, m_affineSegments.MaxIndex(), pIdx, &m_affineSegments);
+            if (pSegment == NULL && min != 0)
+                pSegment = FindScheduleGroupSegment(0, min, pIdx, &m_affineSegments);
+
+            return pSegment;
+        }
+
+        /// <summary>
+        ///     Returns a shared index to pseudo-round robin through non-affine schedule group segments within the ring.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetPseudoRRNonAffineScheduleGroupSegment(int *pIdx)
+        {
+            int min = m_nextNonAffineSegment;
+
+            ScheduleGroupSegmentBase *pSegment = FindScheduleGroupSegment(min, m_nonAffineSegments.MaxIndex(), pIdx, &m_nonAffineSegments);
+            if (pSegment == NULL && min != 0)
+                pSegment = FindScheduleGroupSegment(0, min, pIdx, &m_nonAffineSegments);
+
+            return pSegment;
+        }
+
+        /// <summary>
+        ///     Sets a shared index to pseudo-round robin through affine schedule group segments within the ring.  This sets the index
+        ///     to the schedule group segment *AFTER* idx in the iterator position.
+        /// </summary>
+        void SetPseudoRRAffineScheduleGroupSegmentNext(int idx)
+        {
+            m_nextAffineSegment = (idx + 1) % (m_affineSegments.MaxIndex());
+            ASSERT(m_nextAffineSegment >= 0);
+        }
+
+        /// <summary>
+        ///     Sets a shared index to pseudo-round robin through non-affine schedule group segments within the ring.  This sets the index
+        ///     to the schedule group segment *AFTER* idx in the iterator position.
+        /// </summary>
+        void SetPseudoRRNonAffineScheduleGroupSegmentNext(int idx)
+        {
+            m_nextNonAffineSegment = (idx + 1) % (m_nonAffineSegments.MaxIndex());
+            ASSERT(m_nextNonAffineSegment >= 0);
+        }
+
+        /// <summary>
+        ///     Returns the first affine schedule group segment within the ring.
+        /// </summary>
+        /// <param name="pIdx">
+        ///     The iterator position of the returned schedule group segment will be placed here.  This can only be
+        ///     utilized as the pIdx parameter or the idxStart parameter of a GetNextAffineScheduleGroup.
+        /// </param>
+        ScheduleGroupSegmentBase *GetFirstAffineScheduleGroupSegment(int *pIdx)
+        {
+            return GetFirstScheduleGroupSegment(pIdx, &m_affineSegments);
+        }
+
+        /// <summary>
+        ///     Returns the next affine schedule group segment in an iteration.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetNextAffineScheduleGroupSegment(int *pIdx, int idxStart = 0)
+        {
+            return GetNextScheduleGroupSegment(pIdx, idxStart, &m_affineSegments);
+        }
+
+        /// <summary>
+        ///     Returns the first non-affine schedule group segment within the ring.
+        /// </summary>
+        /// <param name="pIdx">
+        ///     The iterator position of the returned schedule group segment will be placed here.  This can only be
+        ///     utilized as the pIdx parameter or the idxStart parameter of a GetNextNonAffineScheduleGroup.
+        /// </param>
+        ScheduleGroupSegmentBase *GetFirstNonAffineScheduleGroupSegment(int *pIdx)
+        {
+            return GetFirstScheduleGroupSegment(pIdx, &m_nonAffineSegments);
+        }
+
+        /// <summary>
+        ///     Returns the next non-affine schedule group segment in an iteration.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetNextNonAffineScheduleGroupSegment(int *pIdx, int idxStart = 0)
+        {
+            return GetNextScheduleGroupSegment(pIdx, idxStart, &m_nonAffineSegments);
+        }
+
+        /// <summary>
+        ///     Returns the node which owns this ring.
+        /// </summary>
+        SchedulingNode *GetOwningNode() const
+        {
+            return m_pNode;
+        }
+
+        /// <summary>
+        ///     Returns whether this is an active ring or not.
+        /// </summary>
+        bool IsActive() const
+        {
+            return (m_active != 0);
+        }
+
+        /// <summary>
+        ///     Activates the ring.
+        /// </summary>
+        void Activate();
+
+    private:
+        friend class SchedulerBase;
+        friend class ScheduleGroupBase;
+        friend class ScheduleGroupSegmentBase;
+        friend class FairScheduleGroup;
+        friend class CacheLocalScheduleGroup;
+        friend class SchedulingNode;
+        friend class VirtualProcessor;
+        friend class InternalContextBase;
+        friend class ThreadInternalContext;
+
+        // Owning scheduler
+        SchedulerBase *m_pScheduler;
+
+        // Owning Node
+        SchedulingNode *m_pNode;
+
+        // The anonymous schedule group - for external contexts and tasks without an explicitly specified schedule group.
+        // There is one anonymous group segment per scheduling node.
+        ScheduleGroupSegmentBase * m_pAnonymousSegment;
+
+        // Scheduler group segments owned by this ring which have explicitly specified affinity.
+        ListArray<ScheduleGroupSegmentBase> m_affineSegments;
+
+        // Scheduler groups segments owned by this ring which do not have explicitly specified affinity.
+        ListArray<ScheduleGroupSegmentBase> m_nonAffineSegments;
+
+        // Pseudo Round robin indicies.
+        int m_nextAffineSegment;
+        int m_nextNonAffineSegment;
+
+        int m_id;
+
+        // An indication as to whether the ring is active.
+        volatile LONG m_active;
+
+        // Removes the schedule group segment from the appropriate list.
+        void RemoveScheduleGroupSegment(ScheduleGroupSegmentBase* pGroup);
+
+        void SetOwningNode(SchedulingNode *pNode)
+        {
+            m_pNode = pNode;
+        }
+
+        /// <summary>
+        ///     Returns the first schedule group segment in the non-cyclic range [min, max).  If such is found
+        ///     the schedule group segment is returned and pIdx contains its index within the list array.
+        ///     If not found, NULL is returned and the value in pIdx is unspecified.
+        /// </summary>
+        ScheduleGroupSegmentBase *FindScheduleGroupSegment(int min, int max, int *pIdx, ListArray<ScheduleGroupSegmentBase> *pSegmentList)
+        {
+            ScheduleGroupSegmentBase *pSegment = NULL;
+            int i = min;
+            for (; i < max && pSegment == NULL; ++i)
+            {
+                pSegment = (*pSegmentList)[i];
+            }
+
+            //
+            // The loop incremented "i" prior to the check.  If found, the index is i - 1.  If not, we care
+            // not what pIdx contains.
+            //
+            *pIdx = i - 1;
+            return pSegment;
+        }
+
+        /// <summary>
+        ///     Returns the first schedule group.
+        /// </summary>
+        /// <param name="pIdx">
+        ///     The iterator position of the returned schedule group will be placed here.  This can only be
+        ///     utilized as the pIdx parameter or the idxStart parameter of a GetNextScheduleGroup.
+        /// </param>
+        ScheduleGroupSegmentBase *GetFirstScheduleGroupSegment(int *pIdx, ListArray<ScheduleGroupSegmentBase>* pSegmentList)
+        {
+            return FindScheduleGroupSegment(0, pSegmentList->MaxIndex(), pIdx, pSegmentList);
+        }
+
+        /// <summary>
+        ///     Returns the next schedule group in an iteration.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetNextScheduleGroupSegment(int *pIdx, int idxStart, ListArray<ScheduleGroupSegmentBase>* pSegmentList)
+        {
+            ScheduleGroupSegmentBase *pSegment = NULL;
+
+            int min = *pIdx + 1;
+            if (min > idxStart)
+            {
+                pSegment = FindScheduleGroupSegment(min, pSegmentList->MaxIndex(), pIdx, pSegmentList);
+                min = 0;
+            }
+
+            if (pSegment == NULL)
+                pSegment = FindScheduleGroupSegment(min, idxStart, pIdx, pSegmentList);
+
+            return pSegment;
+        }
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SearchAlgorithms.cpp

@@ -0,0 +1,1659 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SearchAlgorithms.cpp
+//
+// Implementation file containing all scheduling algorithms.
+//
+// **PLEASE NOTE**:
+//
+//     Any search algorithm in here must be fully reentrant.  On UMS schedulers, the UMS primary will invoke these routines
+//     to perform a search for work.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    //***************************************************************************
+    //
+    // General:
+    //
+
+    /// <summary>
+    ///     Constructs a work item from an internal context.
+    /// </summary>
+    WorkItem::WorkItem(InternalContextBase *pContext) :
+        m_type(WorkItemTypeContext),
+        m_pSegment(pContext->GetScheduleGroupSegment()),
+        m_pContext(pContext)
+    {
+    }
+
+    /// <summary>
+    ///     Resolves a token to an underlying work item.
+    /// </summary>
+    bool WorkItem::ResolveToken()
+    {
+        CONCRT_COREASSERT(IsToken());
+        switch(m_type)
+        {
+            case WorkItemTypeRealizedChoreToken:
+            {
+                RealizedChore *pChore = m_pSegment->GetRealizedChore();
+                if (pChore != NULL)
+                {
+                    m_pRealizedChore = pChore;
+                    m_type = WorkItemTypeRealizedChore;
+                }
+                break;
+            }
+            case WorkItemTypeUnrealizedChoreToken:
+            {
+                if (m_pWorkQueue == MAILBOX_LOCATION)
+                {
+                    _UnrealizedChore *pChore;
+                    if (!m_pSegment->m_mailedTasks.Dequeue(&pChore))
+                        pChore = NULL;
+
+                    if (pChore != NULL)
+                    {
+                        // The chore may not be from a detached workqueue, but since it is dequeued from a mailbox, we set it as detached
+                        // which will add the stealing context to a list in the task collection instead of the owning contexts stealer collection.
+                        pChore->_SetDetached(true);
+                        m_pUnrealizedChore = pChore;
+                        m_type = WorkItemTypeUnrealizedChore;
+                    }
+                }
+                else
+                {
+                    _UnrealizedChore *pChore = m_pWorkQueue->Steal(false);
+                    if (pChore != NULL)
+                    {
+                        m_pUnrealizedChore = pChore;
+                        m_type = WorkItemTypeUnrealizedChore;
+                    }
+                    break;
+                }
+            }
+        }
+
+        return !IsToken();
+    }
+
+    /// <summary>
+    ///     Binds the work item to a context and returns the context.  This may or may not allocate a new context.  Note that
+    ///     act of binding which performs a context allocation will transfer a single count of work to the counter of the new
+    ///     context.
+    /// </summary>
+    InternalContextBase *WorkItem::Bind()
+    {
+        if (IsToken() && !ResolveToken())
+            return NULL;
+
+        switch(m_type)
+        {
+            case WorkItemTypeUnrealizedChore:
+                m_pContext = m_pSegment->GetInternalContext(m_pUnrealizedChore, true);
+                if (m_pContext != NULL)
+                {
+                    m_pContext->SaveDequeuedTask();
+                    m_type = WorkItemTypeContext;
+                }
+                break;
+            case WorkItemTypeRealizedChore:
+                m_pContext = m_pSegment->GetInternalContext(m_pRealizedChore);
+                if (m_pContext != NULL)
+                {
+                    m_pContext->SaveDequeuedTask();
+                    m_type = WorkItemTypeContext;
+                }
+                break;
+            case WorkItemTypeContext:
+                break;
+        }
+
+        return m_pContext;
+    }
+
+    /// <summary>
+    ///     Binds the work item to the specified context (which is allocated).  This will never allocate a new context.
+    /// </summary>
+    void WorkItem::BindTo(InternalContextBase *pContext)
+    {
+        switch(m_type)
+        {
+            case WorkItemTypeUnrealizedChore:
+                pContext->PrepareForUse(m_pSegment, m_pUnrealizedChore, true);
+                break;
+            case WorkItemTypeRealizedChore:
+                pContext->PrepareForUse(m_pSegment, m_pRealizedChore, false);
+                break;
+        }
+
+        m_pContext = pContext;
+        m_type = WorkItemTypeContext;
+    }
+
+    /// <summary>
+    ///     Invokes the work item.
+    /// </summary>
+    void WorkItem::Invoke()
+    {
+        CONCRT_COREASSERT(m_type == WorkItemTypeRealizedChore || m_type == WorkItemTypeUnrealizedChore);
+        switch(m_type)
+        {
+            case WorkItemTypeUnrealizedChore:
+                m_pUnrealizedChore->_Invoke();
+                break;
+            case WorkItemTypeRealizedChore:
+                m_pRealizedChore->Invoke();
+                m_pSegment->GetGroup()->GetScheduler()->ReleaseRealizedChore(m_pRealizedChore);
+                break;
+        }
+    }
+
+    /// <summary>
+    ///     Transfers reference counts as necessary to inline the given work item on the given context.  This may
+    ///     only be called on a work item that can be inlined (e.g.: an unbound one).
+    /// </summary>
+    /// <param name="pContext">
+    ///     The context that is attempting to inline the work item.
+    /// </param>
+    void WorkItem::TransferReferences(InternalContextBase *pContext)
+    {
+        ASSERT(m_type == WorkItemTypeRealizedChore || m_type == WorkItemTypeUnrealizedChore);
+
+        ScheduleGroupSegmentBase *pSegment = pContext->GetScheduleGroupSegment();
+        if (m_type == WorkItemTypeRealizedChore)
+        {
+            if (pSegment->GetGroup() != m_pSegment->GetGroup())
+            {
+                pContext->SwapScheduleGroupSegment(m_pSegment, false);
+            }
+            else
+            {
+                //
+                // If newGroup is the same as the existing group, we need to release a reference since both, the context,
+                // and the realized chore, have a reference on the schedule group, and we only need to hold one reference.
+                //
+                OMTRACE(MTRACE_EVT_WORKITEMDEREFERENCE, pSegment->GetGroup(), NULL, NULL, 0);
+                pSegment->GetGroup()->InternalRelease();
+            }
+
+        }
+        else if (pSegment->GetGroup() != m_pSegment->GetGroup())
+        {
+            pContext->SwapScheduleGroupSegment(m_pSegment, true);
+        }
+    }
+
+    /// <summary>
+    ///     Resets the work search context to utilize the specified algorithm at the starting iterator position.
+    /// </summary>
+    /// <param name="pVirtualProcessor">
+    ///     The virtual processor binding the searching.
+    /// </param>
+    /// <param name="algorithm">
+    ///     The algorithm to reset the iterator with.
+    /// </param>
+    void WorkSearchContext::Reset(VirtualProcessor *pVirtualProcessor, Algorithm algorithm)
+    {
+        m_LRCBias = 0;;
+        m_pVirtualProcessor = pVirtualProcessor;
+        m_maskId = m_pVirtualProcessor->GetMaskId();
+        m_pScheduler = pVirtualProcessor->GetOwningNode()->GetScheduler();
+        m_serviceTick = m_lastPriorityPull = platform::__GetTickCount64();
+
+        switch(algorithm)
+        {
+            case AlgorithmCacheLocal:
+                m_pSearchFn = &WorkSearchContext::SearchCacheLocal;
+                m_pSearchYieldFn = &WorkSearchContext::SearchCacheLocalYield;
+                break;
+            case AlgorithmFair:
+                m_pSearchFn = &WorkSearchContext::SearchFair;
+                m_pSearchYieldFn = &WorkSearchContext::SearchFairYield;
+                break;
+            default:
+                ASSERT(false);
+        }
+    }
+
+    /// <summary>
+    ///     Steals a local runnable from a virtual processor within the specified node.  Note that this allows a given virtual processor
+    ///     to be skipped.
+    /// </summary>
+    bool WorkSearchContext::StealLocalRunnable(WorkItem *pWorkItem, SchedulingNode *pNode, VirtualProcessor *pSkipVirtualProcessor)
+    {
+        int idx;
+        VirtualProcessor *pVProc = pNode->GetFirstVirtualProcessor(&idx);
+        while (pVProc != NULL)
+        {
+            if (pVProc != pSkipVirtualProcessor)
+            {
+                pVProc->ServiceMark(m_serviceTick);
+                InternalContextBase *pContext = pVProc->StealLocalRunnableContext();
+                if (pContext != NULL)
+                {
+                    *pWorkItem = WorkItem(pContext);
+                    return true;
+                }
+            }
+
+            pVProc = pNode->GetNextVirtualProcessor(&idx);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Steals a local runnable from a virtual processor of any scheduling node other than the specified local node.
+    /// </summary>
+    bool WorkSearchContext::StealForeignLocalRunnable(WorkItem *pWorkItem, SchedulingNode *pLocalNode)
+    {
+        int idx;
+        SchedulingNode *pNode = m_pScheduler->GetFirstSchedulingNode(&idx);
+        while (pNode != NULL)
+        {
+            if (pNode != pLocalNode)
+            {
+                if (StealLocalRunnable(pWorkItem, pNode, NULL))
+                    return true;
+            }
+
+            pNode = m_pScheduler->GetNextSchedulingNode(&idx);
+        }
+
+        return false;
+
+    }
+
+    /// <summary>
+    ///     Performs a pre-search for any "special" contexts (e.g.: the UMS SUT)
+    /// </summary>
+    bool WorkSearchContext::PreSearch(WorkItem *pWorkItem)
+    {
+        InternalContextBase *pContext = m_pVirtualProcessor->PreRunnableSearch();
+        if (pContext != NULL)
+        {
+            *pWorkItem = WorkItem(pContext);
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Gets a local runnable context from the specified virtual processor.
+    /// </summary>
+    bool WorkSearchContext::GetLocalRunnable(WorkItem *pWorkItem, VirtualProcessor *pVirtualProcessor, bool fYieldingSearch)
+    {
+        if (fYieldingSearch)
+        {
+            InternalContextBase *pContext = pVirtualProcessor->GetLocalRunnableContext();
+            if (pContext != NULL)
+            {
+                *pWorkItem = WorkItem(pContext);
+                return true;
+            }
+        }
+        else
+        {
+            BiasStageType biasStage = BiasStage();
+            if (biasStage < BiasStageSkipLRC)
+            {
+                InternalContextBase *pContext = (biasStage == BiasStageFlipLRC) ? pVirtualProcessor->StealLocalRunnableContext() : pVirtualProcessor->GetLocalRunnableContext();
+                if (pContext != NULL)
+                {
+                    *pWorkItem = WorkItem(pContext);
+                    LRCBias();
+                    return true;
+                }
+            }
+
+            ResetLRCBias();
+        }
+        return false;
+    }
+
+    /// <summary>
+    ///     Gets a runnable from the specified schedule group segment.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     The schedule group segment in which to look for a runnable context.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether or not a runnable context was found in the segment.
+    /// </returns>
+    bool WorkSearchContext::GetRunnableContext(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment)
+    {
+        InternalContextBase *pContext = pSegment->GetRunnableContext();
+        if (pContext != NULL)
+        {
+            *pWorkItem = WorkItem(pContext);
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Gets a realized chore from the specified schedule group segment.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     The schedule group segment in which to look for a realized chore.
+    /// </param>
+    /// <param name="fRealWork">
+    ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+    ///     is resolved.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether or not a realized chore was found in the segment.
+    /// </returns>
+    bool WorkSearchContext::GetRealizedChore(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork)
+    {
+        if (fRealWork)
+        {
+            RealizedChore *pRealizedChore = pSegment->GetRealizedChore();
+            if (pRealizedChore != NULL)
+            {
+                *pWorkItem = WorkItem(pRealizedChore, pSegment);
+                return true;
+            }
+        }
+        else
+        {
+            if (pSegment->HasRealizedChores())
+            {
+                *pWorkItem = WorkItem(pSegment);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Gets an unrealized chore from the specified schedule group segment.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     The schedule group segment in which to look for an unrealized chore.
+    /// </param>
+    /// <param name="fForceStealLocalized">
+    ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+    ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+    ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+    /// </param>
+    /// <param name="fRealWork">
+    ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+    ///     is resolved.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether or not an unrealized chore was found in the segment.
+    /// </returns>
+    bool WorkSearchContext::GetUnrealizedChore(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fForceStealLocalized, bool fRealWork)
+    {
+        if (fRealWork)
+        {
+            _UnrealizedChore *pUnrealizedChore = pSegment->StealUnrealizedChore(fForceStealLocalized);
+            if (pUnrealizedChore != NULL)
+            {
+                *pWorkItem = WorkItem(pUnrealizedChore, pSegment);
+                return true;
+            }
+        }
+        else
+        {
+            // We should never be in the last pass of search for work (which is when fForceStealLocalized is set to true) if we're looking for a token.
+            ASSERT(!fForceStealLocalized);
+            WorkQueue *pWorkQueue = pSegment->LocateUnrealizedChores();
+            if (pWorkQueue != NULL)
+            {
+                *pWorkItem = WorkItem(pWorkQueue, pSegment);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Performs a quick search of a particular segment.
+    /// </summary>
+    bool WorkSearchContext::QuickSearch(ScheduleGroupSegmentBase *pQCSegment,
+                                        WorkItem *pWorkItem,
+                                        bool fLastPass,
+                                        ULONG allowableTypes)
+    {
+        if (((allowableTypes & WorkItem::WorkItemTypeContext) && GetRunnableContext(pWorkItem, pQCSegment)) ||
+            ((allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore) &&
+                GetRealizedChore(pWorkItem, pQCSegment, !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore))) ||
+            ((allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore) &&
+                GetUnrealizedChore(pWorkItem, pQCSegment, fLastPass, !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore))))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Performs a quick yielding search of a particular segment.
+    /// </summary>
+    bool WorkSearchContext::QuickSearchYield(ScheduleGroupSegmentBase *pQCSegment,
+                                             WorkItem *pWorkItem,
+                                             bool fLastPass,
+                                             ULONG allowableTypes)
+    {
+        if (((allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore) &&
+                GetUnrealizedChore(pWorkItem, pQCSegment, fLastPass, !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore))) ||
+            ((allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore) &&
+                GetRealizedChore(pWorkItem, pQCSegment, !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore))) ||
+            ((allowableTypes & WorkItem::WorkItemTypeContext) && GetRunnableContext(pWorkItem, pQCSegment)))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Determines if a segment should be skipped given the search parameters and the segment's affinity.
+    /// </summary>
+    /// <param name="pSegment">
+    ///     The segment to query about skipping.
+    /// </param>
+    /// <param name="pSkipSegment">
+    ///     A segment which should be arbitrarily skipped regardless of affinity type.  This parameter can be NULL.
+    /// </param>
+    /// <param name="affinity">
+    ///     The search affinity type to query for.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication as to whether pSegment should be skipped according to the pSkipSegment and affinity parameters.
+    /// </returns>
+    bool WorkSearchContext::SkipSegmentSearch(ScheduleGroupSegmentBase *pSegment, ScheduleGroupSegmentBase *pSkipSegment, SearchAffinity affinity, bool fLastPass)
+    {
+        if (pSegment == pSkipSegment)
+        {
+            return true;
+        }
+
+        bool fSkip = false;
+        const location& segmentAffinity = pSegment->GetAffinity();
+
+        switch(affinity)
+        {
+            case SearchNonAffine:
+                //
+                // Skip if it has any affinity and we're looking for non-affine work.
+                //
+                fSkip = !segmentAffinity._Is_system();
+                break;
+
+            case SearchAffineLocal:
+                //
+                // Skip if it has specific affinity to something that doesn't intersect with us.
+                //
+                fSkip = segmentAffinity._Is_system() || !m_pVirtualProcessor->GetLocation()._FastVPIntersects(segmentAffinity);
+                break;
+
+            case SearchAffineNotMe:
+                //
+                // Skip if it has specific affinity to us **OR** the virtual processors to which it has affinity are in the middle
+                // of search-for-work.  This is an optimization to prevent us from ripping affine work out from underneath someone who
+                // will soon find it.
+                //
+                // In the last pass of SFW, we ignore this heuristic in order to avoid deadlock in required dependence cases.
+                //
+                fSkip = segmentAffinity._Is_system() ||
+                        (m_pVirtualProcessor->GetLocation()._FastVPIntersects(segmentAffinity) ||
+                            (m_pScheduler->HasSearchers(pSegment->GetAffinitySet()) && !fLastPass));
+                break;
+
+            default:
+                break;
+
+        }
+
+        return fSkip;
+    }
+
+    /// <summary>
+    ///     Searches the schedule group to which pSegment belongs to find a runnable.  The group is searched for segments according to the specified
+    ///     affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If an appropriate runnable is found, the resulting work item will be placed here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a work item was found or not.
+    /// </returns>
+    bool WorkSearchContext::GetRunnableContextWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, SearchAffinity affinity, bool fLastPass)
+    {
+        ScheduleGroupBase *pGroup = pSegment->GetGroup();
+
+        //
+        // @TODO_LOC:
+        //
+        // We need to slice this differently so that we pick up "local" affine work before "non-local" affine work, etc...
+        //
+        if (!SkipSegmentSearch(pSegment, NULL, affinity, fLastPass) && GetRunnableContext(pWorkItem, pSegment))
+        {
+            return true;
+        }
+
+        ScheduleGroupSegmentBase *pCurSegment = pGroup->GetFirstScheduleGroupSegment(affinity != SearchNonAffine);
+        while(pCurSegment != NULL)
+        {
+            if (!SkipSegmentSearch(pCurSegment, pSegment, affinity, fLastPass) && GetRunnableContext(pWorkItem, pCurSegment))
+            {
+                return true;
+            }
+
+            pCurSegment = pGroup->GetNextScheduleGroupSegment(pCurSegment);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Searches the schedule group to which pSegment belongs to find a realized chore.  The group is searched for segments according to the specified
+    ///     affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If an appropriate realized chore is found, the resulting work item will be placed here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a work item was found or not.
+    /// </returns>
+    bool WorkSearchContext::GetRealizedChoreWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork, SearchAffinity affinity, bool fLastPass)
+    {
+        ScheduleGroupBase *pGroup = pSegment->GetGroup();
+
+        //
+        // @TODO_LOC:
+        //
+        // We need to slice this differently so that we pick up "local" affine work before "non-local" affine work, etc...
+        //
+        if (!SkipSegmentSearch(pSegment, NULL, affinity, fLastPass) && GetRealizedChore(pWorkItem, pSegment, fRealWork))
+        {
+            return true;
+        }
+
+        ScheduleGroupSegmentBase *pCurSegment = pGroup->GetFirstScheduleGroupSegment(affinity != SearchNonAffine);
+        while(pCurSegment != NULL)
+        {
+            if (!SkipSegmentSearch(pCurSegment, pSegment, affinity, fLastPass) && GetRealizedChore(pWorkItem, pCurSegment, fRealWork))
+            {
+                return true;
+            }
+
+            pCurSegment = pGroup->GetNextScheduleGroupSegment(pCurSegment);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Searches the schedule group to which pSegment belongs to find an unrealized chore.  The group is searched for segments according to the
+    ///     specified affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If an appropriate unrealized chore is found, the resulting work item will be placed here.
+    /// </param>
+    /// <param name="pSegment">
+    ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a work item was found or not.
+    /// </returns>
+    bool WorkSearchContext::GetUnrealizedChoreWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork, SearchAffinity affinity, bool fLastPass)
+    {
+        ScheduleGroupBase *pGroup = pSegment->GetGroup();
+
+        //
+        // @TODO_LOC:
+        //
+        // We need to slice this differently so that we pick up "local" affine work before "non-local" affine work, etc...  We also might need to
+        // slice out pSegment first.  The second aspect requires more thought.
+        //
+        if (!SkipSegmentSearch(pSegment, NULL, affinity, fLastPass) && GetUnrealizedChore(pWorkItem, pSegment, fLastPass, fRealWork))
+        {
+            return true;
+        }
+
+        ScheduleGroupSegmentBase *pCurSegment = pGroup->GetFirstScheduleGroupSegment(affinity != SearchNonAffine);
+        while(pCurSegment != NULL)
+        {
+            if (!SkipSegmentSearch(pCurSegment, pSegment, affinity, fLastPass) && GetUnrealizedChore(pWorkItem, pCurSegment, fLastPass, fRealWork))
+            {
+                return true;
+            }
+
+            pCurSegment = pGroup->GetNextScheduleGroupSegment(pCurSegment);
+        }
+
+        return false;
+    }
+
+
+    //***************************************************************************
+    //
+    // Fair Searches
+    //
+    // NOTE: At present, we completely ignore affine lists because fair schedulers ignore location hints.  This means you cannot "switch" scheduling
+    //       to fair on a cache local scheduler should that ever come up.
+    //
+
+    /// <summary>
+    ///     Performs a fair search for runnables in the specified ring.
+    /// </summary>
+    bool WorkSearchContext::SearchFair_Runnables(WorkItem *pWorkItem, SchedulingRing *pRing)
+    {
+        int idx;
+        ScheduleGroupSegmentBase *pSegment = pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL)
+        {
+            InternalContextBase *pContext = pSegment->GetRunnableContext();
+            if (pContext != NULL)
+            {
+                pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                *pWorkItem = WorkItem(pContext);
+                return true;
+            }
+
+            pSegment = pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+
+    }
+
+    /// <summary>
+    ///     Performs a fair search for realized chores in the specified ring.
+    /// </summary>
+    bool WorkSearchContext::SearchFair_Realized(WorkItem *pWorkItem, SchedulingRing *pRing, bool fRealItem)
+    {
+        int idx;
+        ScheduleGroupSegmentBase *pSegment = pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL)
+        {
+            if (fRealItem)
+            {
+                RealizedChore *pRealizedChore = pSegment->GetRealizedChore();
+                if (pRealizedChore != NULL)
+                {
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                    *pWorkItem = WorkItem(pRealizedChore, pSegment);
+                    return true;
+                }
+            }
+            else
+            {
+                if (pSegment->HasRealizedChores())
+                {
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                    *pWorkItem = WorkItem(pSegment);
+                    return true;
+                }
+            }
+
+            pSegment = pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+
+    }
+
+    /// <summary>
+    ///     Performs a fair search for unrealized chores in the specified ring.
+    /// </summary>
+    bool WorkSearchContext::SearchFair_Unrealized(WorkItem *pWorkItem, SchedulingRing *pRing, bool fRealItem)
+    {
+        int idx;
+        ScheduleGroupSegmentBase *pSegment = pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL)
+        {
+            if (fRealItem)
+            {
+                _UnrealizedChore *pUnrealizedChore = pSegment->StealUnrealizedChore();
+                if (pUnrealizedChore != NULL)
+                {
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                    *pWorkItem = WorkItem(pUnrealizedChore, pSegment);
+                    return true;
+                }
+            }
+            else
+            {
+                WorkQueue *pWorkQueue = pSegment->LocateUnrealizedChores();
+                if (pWorkQueue != NULL)
+                {
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                    *pWorkItem = WorkItem(pWorkQueue, pSegment);
+                    return true;
+                }
+            }
+
+            pSegment = pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+
+    }
+
+    /// <summary>
+    ///     Performs a fair search for work.
+    /// </summary>
+    bool WorkSearchContext::SearchFair(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool, ULONG allowableTypes)
+    {
+        bool fFound = false;
+
+        CONCRT_COREASSERT(pOriginSegment != NULL);
+        //
+        // Do any up-front searching required for special circumstances (e.g.: UMS schedulers)
+        //
+        if (PreSearch(pWorkItem))
+            return true;
+
+        //
+        // The fair search essentially round robins among scheduling rings and groups within a ring.
+        // If you consider the search space as follows:
+        //
+        //               SR      SR     SR     SR
+        // Contexts      ---------------------->
+        // Realized      ---------------------->
+        // Unrealized    ---------------------->
+        //
+        // fair scheduling will make horizontal slices through the search space to find work.
+        //
+        // Each entry in the above matrix can be viewed as:
+        //
+        // SG -> SG -> SG -> SG
+        //
+        // However, after finding work in a particular ring, fair will move onto the next ring in round-robin fashion.
+        //
+
+        //
+        // At the top of each search, reset to the next ring in the round robin index.  This is simply the starting point for this search.
+        //
+        SchedulingRing *pStartingRing = m_pScheduler->GetNextSchedulingRing();
+
+        if (allowableTypes & WorkItem::WorkItemTypeContext)
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Runnables(pWorkItem, pRing);
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+
+            if (!fFound)
+                fFound = StealForeignLocalRunnable(pWorkItem, m_pVirtualProcessor->GetOwningNode());
+        }
+
+        if (!fFound && (allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore))
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Realized(pWorkItem, pRing, !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore));
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+        }
+
+        if (!fFound && (allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore))
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Unrealized(pWorkItem, pRing, !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore));
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+        }
+
+        return fFound;
+    }
+
+    /// <summary>
+    ///     Performs a fair search for work in the yielding case.
+    /// </summary>
+    bool WorkSearchContext::SearchFairYield(WorkItem *pWorkItem, ScheduleGroupSegmentBase *, bool, ULONG allowableTypes)
+    {
+        //
+        // The yielding case slices identically to the regular case excepting that the search is done in a pseudo-reverse order
+        //
+        bool fFound = false;
+
+        //
+        // Do any up-front searching required for special circumstances (e.g.: UMS schedulers)
+        //
+        if (PreSearch(pWorkItem))
+            return true;
+
+        //
+        // At the top of each search, reset to the next ring in the round robin index.  This is simply the starting point for this search.
+        //
+        SchedulingRing *pStartingRing = m_pScheduler->GetNextSchedulingRing();
+
+        if (allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore)
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Unrealized(pWorkItem, pRing, !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore));
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+        }
+
+
+        if (!fFound && (allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore))
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Realized(pWorkItem, pRing, !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore));
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+        }
+
+        if (!fFound && (allowableTypes & WorkItem::WorkItemTypeContext))
+        {
+            SchedulingRing *pRing = pStartingRing;
+            while (pRing != NULL)
+            {
+                fFound = SearchFair_Runnables(pWorkItem, pRing);
+                if (fFound)
+                {
+                    m_pScheduler->SetNextSchedulingRing(pRing);
+                    break;
+                }
+
+                pRing = m_pScheduler->GetNextSchedulingRing(pStartingRing, pRing);
+            }
+
+            if (!fFound)
+                fFound = StealForeignLocalRunnable(pWorkItem, m_pVirtualProcessor->GetOwningNode());
+        }
+
+        return fFound;
+
+    }
+
+    //***************************************************************************
+    //
+    // Cache Local Searches
+    //
+
+    /// <summary>
+    ///     Searches for a runnable within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+    ///     pBiasSegment according to the rules of the search and the requested affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pRing">
+    ///     The scheduling ring to search.
+    /// </param>
+    /// <param name="pBiasSegment">
+    ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+    /// </param>
+    /// <param name="fOtherLocalLRCCheck">
+    ///     Determines whether or not to check other local LRCs in this search.
+    /// </param>
+    /// <param name="affinity">
+    ///     The search affinity type to query for.
+    /// </param>
+    /// <param name="allowableTypes">
+    ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+    ///     can be returned as well as whether the actual work item or only a token should be returned.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a runnable was found in the bias segment, group, or the specified ring.
+    /// </returns>
+    bool WorkSearchContext::SearchCacheLocal_Runnables(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                                       bool fOtherLocalLRCCheck, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass)
+    {
+        if (pBiasSegment != NULL && GetRunnableContextWithinGroup(pWorkItem, pBiasSegment, affinity, fLastPass))
+        {
+            return true;
+        }
+
+        //
+        // As much as I abhor the one off placement of this here, it's the "cleanest" place to put this for its given location within SFW.
+        // Attempt to steal a local runnable context from the current node.
+        //
+        if (fOtherLocalLRCCheck && StealLocalRunnable(pWorkItem, m_pVirtualProcessor->GetOwningNode(), m_pVirtualProcessor))
+        {
+            return true;
+        }
+
+        int idx;
+        ScheduleGroupSegmentBase *pSegment =
+            (affinity == SearchNonAffine) ?  pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx) : pRing->GetPseudoRRAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL)
+        {
+            ScheduleGroupSegmentBase *pQCSegment = m_pScheduler->AcquireQuickCacheSlot(m_maskId);
+            if (pQCSegment)
+            {
+                if (QuickSearch(pQCSegment, pWorkItem, fLastPass, allowableTypes))
+                    return true;
+            }
+
+            //
+            // Is this a segment we should skip:
+            //
+            //     - If we are explicitly told to skip it in the search because it was checked elsewhere (pSkipSegment).
+            //     - If we are searching for affine work and it matches or doesn't match the search context affinity as dictated by the affinity parameter.
+            //
+            if (!SkipSegmentSearch(pSegment, pBiasSegment, affinity, fLastPass) && GetRunnableContext(pWorkItem, pSegment))
+            {
+                if (affinity == SearchNonAffine)
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                else
+                    pRing->SetPseudoRRAffineScheduleGroupSegmentNext(idx);
+
+                return true;
+            }
+
+            pSegment = (affinity == SearchNonAffine) ? pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart) :
+                                                     pRing->GetNextAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+
+    }
+
+    /// <summary>
+    ///     Searches for a realized chore within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+    ///     pBiasSegment according to the rules of the search and the requested affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pRing">
+    ///     The scheduling ring to search.
+    /// </param>
+    /// <param name="pBiasSegment">
+    ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+    /// </param>
+    /// <param name="fRealWork">
+    ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+    ///     is resolved.
+    /// </param>
+    /// <param name="affinity">
+    ///     The search affinity type to query for.
+    /// </param>
+    /// <param name="allowableTypes">
+    ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+    ///     can be returned as well as whether the actual work item or only a token should be returned.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a realized chore was found in the bias segment, group, or the specified ring.
+    /// </returns>
+    bool WorkSearchContext::SearchCacheLocal_Realized(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                                      bool fRealWork, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass)
+    {
+        bool fFound = false;
+
+        if (pBiasSegment != NULL && GetRealizedChoreWithinGroup(pWorkItem, pBiasSegment, fRealWork, affinity, fLastPass))
+        {
+            return true;
+        }
+
+        int idx;
+        ScheduleGroupSegmentBase *pSegment =
+            (affinity == SearchNonAffine) ? pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx) : pRing->GetPseudoRRAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL && !fFound)
+        {
+            ScheduleGroupSegmentBase *pQCSegment = m_pScheduler->AcquireQuickCacheSlot(m_maskId);
+            if (pQCSegment)
+            {
+                if (QuickSearch(pQCSegment, pWorkItem, fLastPass, allowableTypes))
+                    return true;
+            }
+
+            //
+            // Is this a segment we should skip:
+            //
+            //     - If we are explicitly told to skip it in the search because it was checked elsewhere (pSkipSegment).
+            //     - If we are searching for affine work and it matches or doesn't match the search context affinity as dictated by the affinity parameter.
+            //
+            if (!SkipSegmentSearch(pSegment, pBiasSegment, affinity, fLastPass) && GetRealizedChore(pWorkItem, pSegment, fRealWork))
+            {
+                if (affinity == SearchNonAffine)
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                else
+                    pRing->SetPseudoRRAffineScheduleGroupSegmentNext(idx);
+
+                return true;
+            }
+
+            pSegment = (affinity == SearchNonAffine) ? pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart) :
+                                                       pRing->GetNextAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Searches for an unrealized chore within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+    ///     pBiasSegment according to the rules of the search and the requested affinity type.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pRing">
+    ///     The scheduling ring to search.
+    /// </param>
+    /// <param name="pBiasSegment">
+    ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+    /// </param>
+    /// <param name="fRealWork">
+    ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+    ///     is resolved.
+    /// </param>
+    /// <param name="affinity">
+    ///     The search affinity type to query for.
+    /// </param>
+    /// <param name="allowableTypes">
+    ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+    ///     can be returned as well as whether the actual work item or only a token should be returned.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether an unrealized chore was found in the bias segment, group, or the specified ring.
+    /// </returns>
+    bool WorkSearchContext::SearchCacheLocal_Unrealized(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                                        bool fRealWork, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass)
+    {
+        bool fFound = false;
+
+        if (pBiasSegment != NULL && GetUnrealizedChoreWithinGroup(pWorkItem, pBiasSegment, fRealWork, affinity, fLastPass))
+        {
+            return true;
+        }
+
+        int idx;
+        ScheduleGroupSegmentBase *pSegment =
+            (affinity == SearchNonAffine) ? pRing->GetPseudoRRNonAffineScheduleGroupSegment(&idx) : pRing->GetPseudoRRAffineScheduleGroupSegment(&idx);
+
+        int idxStart = idx;
+
+        while (pSegment != NULL && !fFound)
+        {
+            ScheduleGroupSegmentBase *pQCSegment = m_pScheduler->AcquireQuickCacheSlot(m_maskId);
+            if (pQCSegment)
+            {
+                if (QuickSearch(pQCSegment, pWorkItem, fLastPass, allowableTypes))
+                    return true;
+            }
+
+            //
+            // Is this a segment we should skip:
+            //
+            //     - If we are explicitly told to skip it in the search because it was checked elsewhere (pSkipSegment).
+            //     - If we are searching for affine work and it matches or doesn't match the search context affinity as dictated by the affinity parameter.
+            //
+            if (!SkipSegmentSearch(pSegment, pBiasSegment, affinity, fLastPass) && GetUnrealizedChore(pWorkItem, pSegment, fLastPass, fRealWork))
+            {
+                if (affinity == SearchNonAffine)
+                    pRing->SetPseudoRRNonAffineScheduleGroupSegmentNext(idx);
+                else
+                    pRing->SetPseudoRRAffineScheduleGroupSegmentNext(idx);
+
+                return true;
+            }
+
+            pSegment = (affinity == SearchNonAffine) ? pRing->GetNextNonAffineScheduleGroupSegment(&idx, idxStart) :
+                                                       pRing->GetNextAffineScheduleGroupSegment(&idx, idxStart);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Searches for work within the scheduler according to the cache local (schedule group local) search algorithm.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pOriginSegment">
+    ///     The segment to bias the search to.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <param name="allowableTypes">
+    ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+    ///     can be returned as well as whether the actual work item or only a token should be returned.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a work item was found or not.
+    /// </returns>
+    bool WorkSearchContext::SearchCacheLocal(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes)
+    {
+        bool fFound = false;
+
+        if (PreSearch(pWorkItem))
+            return true;
+
+        ASSERT(pOriginSegment);
+
+        m_serviceTick = platform::__GetTickCount64();
+        m_pScheduler->PeriodicScan(m_serviceTick);
+
+        //
+        // @TODO: This is a temporary patch until we have priority and boosts in the scheduler.  Right now, search for any segment in the locked
+        // FIFO of "priority" segments to see if we need to service someone to avoid livelock.  We also periodically scan to determine whether
+        // groups need to go into this list.
+        //
+
+        if (CheckPriorityList(m_serviceTick))
+        {
+            if (m_pScheduler->HasPriorityObjects())
+            {
+                BoostedObject *pObject = m_pScheduler->GetNextPriorityObject();
+                while (pObject != NULL)
+                {
+                    if (pObject->IsScheduleGroupSegment())
+                    {
+                        ScheduleGroupSegmentBase *pSegment = ScheduleGroupSegmentBase::FromBoostEntry(pObject);
+                        OMTRACE(MTRACE_EVT_PRIORITYPULL, pSegment, NULL, m_pVirtualProcessor, 0);
+                        if (QuickSearch(pSegment, pWorkItem, fLastPass, allowableTypes))
+                        {
+                            fFound = true;
+                            break;
+                        }
+                    }
+                    else if (allowableTypes & WorkItem::WorkItemTypeContext)
+                    {
+                        VirtualProcessor *pVProc = VirtualProcessor::FromBoostEntry(pObject);
+                        InternalContextBase *pContext = pVProc->StealLocalRunnableContext();
+                        if (pContext != NULL)
+                        {
+                            *pWorkItem = WorkItem(pContext);
+                            fFound = true;
+                            break;
+                        }
+                    }
+
+                    pObject = m_pScheduler->GetNextPriorityObject();
+                }
+            }
+
+            //
+            // If we found something in a priority segment, we need to mark the V-Proc so that it once again looks for affinitized work
+            // the next time through SFW.
+            //
+            m_pVirtualProcessor->MarkGrabbedPriority();
+        }
+
+        SchedulingRing *pOwningRing = m_pVirtualProcessor->GetOwningRing();
+
+        if (!fFound)
+        {
+            //
+            // Before describing the cache local search algorithm, some definitions to aid in this are in order:
+            //
+            // Work:
+            //     local work      -- Work within a node/ring that a given virtual processor belongs to is considered local work
+            //     foreign work    -- Work within a node/ring that a given virtual processor does *NOT* belong to is considered foreign work
+            //     affine work     -- Work which is placed at a location more specific than the system location is affine work
+            //     non-affine work -- Work which is placed at the system location (or no location) is considered non-affine work
+            //
+            // Virtual Processors:
+            //     rambling   -- a given virtual processor is *rambling* when it is executing foreign work (regardless whether such work is affine to it or not)
+            //     non-affine -- a given virtual processor is *non-affine* when it is executing non-affine work (regardless whether it is rambling or not)
+            //
+            // Virtual processors which are rambling or are executing non-affine work are tracked by the scheduler.  When such virtual processors
+            // exist, notifications will be published whenever affine work or local work becomes available.
+            //
+
+            //
+            // Look for work in the scheduler.  **IN GENERAL**, we want to find work in the following order of precedence:
+            //
+            // Phase 1: Affine work
+            //       Affine work in our current group (preferring local affine work)
+            //       Local affine (to us) work (in our starting (home) ring)
+            //       Foreign affine (to us) work (in foreign ring segments that match our affinity mask -- such have a segment in our ring by definition)
+            //
+            //       - This phase may be skipped if we are executing non-affine work and have not received an affinity notification from the scheduler.
+            //         Doing so prevents SFW from making a full pass per work item if no affinity has been used.
+            //
+            // Phase 2: Non-affine work
+            //       Non-Affine work in our current group (preferring local work)
+            //       Local non-affine work (in our starting (home ring))
+            //       Foreign non-affine work (in foreign rings).
+            //
+            //       - This phase may *NEVER* be skipped.
+            //
+            // Phase 3: Affine work (non-local)
+            //       Non-local affine (*NOT* to us) work (in foreign ring segments that do not match our affinity mask
+            //
+            //       - This phase may be skipped in theory if we know that there is no affine work in the scheduler.  For a case with no affinity used within
+            //         any scheduling API, this phase is only hit if the scheduler is completely idle.  At idle, performing a pass is likely little additional
+            //         cost to any performance sensitive scenario.  At present, this stage is not skipped for this reason.
+            //
+            // At a very high level, you can consider a cache local search to be making vertical slices through the search space as follows:
+            //
+            //               SR      SR     SR     SR
+            // Contexts      |       |      |      |
+            // Realized      |       |      |      |
+            // Unrealized    v       v      v      v
+            //
+            // where each entry in this matrix is a piece of a schedule group.
+            //
+            // Note that in the last pass of SFW, we cannot skip phases or segments.  Doing so can lead us to deadlock in cases with required dependence
+            // (assumptions on concurrency level).
+            //
+            static const SearchAffinity phaseAffinities[] = { SearchAffineLocal, SearchNonAffine, SearchAffineNotMe };
+            //                                              {       1          ,       0        ,         2         };
+            int startPhaseIndex = (!m_pVirtualProcessor->ExecutingAffine() && !m_pVirtualProcessor->CheckAffinityNotification() && !fLastPass) ? 1 : 0;
+            int maxPhaseIndex = SIZEOF_ARRAY(phaseAffinities) - 1;
+
+            // Make sure we only check the vproc's LRC and local node LRCs once.  This is done in this manner to ensure the odd placement of this within the
+            // search algorithm. This variable is set to false at the end of the first pass through the inner loop.
+            bool fLocalCheck = true;
+            for(int phaseIndex = startPhaseIndex; !fFound && phaseIndex <= maxPhaseIndex; ++phaseIndex) // This loop goes through the phases in the phaseAffinity array.
+            {
+                SearchAffinity srchType = phaseAffinities[phaseIndex];
+
+                // At the outset of every pass, we bias to the originating segment/group and the current virtual processors owning ring.
+                // Note that if we are searching for non-local affinework, we skip the owning ring (by definition, it's local).
+                ScheduleGroupSegmentBase *pBiasSegment = pOriginSegment;
+                SchedulingRing *pRing = pOwningRing;
+
+                while (pRing != NULL)
+                {
+                    ScheduleGroupSegmentBase* pQCSegment = m_pScheduler->AcquireQuickCacheSlot(m_maskId);
+                    if (pQCSegment)
+                    {
+                        if (QuickSearch(pQCSegment, pWorkItem, fLastPass, allowableTypes))
+                        {
+                            fFound = true;
+                            break;
+                        }
+                    }
+
+                    if ((fLocalCheck && (allowableTypes & WorkItem::WorkItemTypeContext) &&
+                            GetLocalRunnable(pWorkItem, m_pVirtualProcessor, false)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeContext) &&
+                            SearchCacheLocal_Runnables(pWorkItem,
+                                                       pRing,
+                                                       pBiasSegment,
+                                                       fLocalCheck,
+                                                       srchType,
+                                                       allowableTypes,
+                                                       fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore) &&
+                            SearchCacheLocal_Realized(pWorkItem,
+                                                      pRing,
+                                                      pBiasSegment,
+                                                      !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore),
+                                                      srchType,
+                                                      allowableTypes,
+                                                      fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore) &&
+                            SearchCacheLocal_Unrealized(pWorkItem,
+                                                        pRing,
+                                                        pBiasSegment,
+                                                        !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore),
+                                                        srchType,
+                                                        allowableTypes,
+                                                        fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeContext) && phaseIndex == maxPhaseIndex &&
+                            StealLocalRunnable(pWorkItem, pRing->GetOwningNode(), m_pVirtualProcessor)))
+                    {
+                        fFound = true;
+                        break;
+                    }
+
+                    // Make sure we only steal from vproc LRCs in the local node once.  This is done in this manner to ensure the odd placement of this within the
+                    // search algorithm.
+                    fLocalCheck = false;
+
+                    // The first time through the loop, not only did we bias to pBiasSegment, but to pStartingRing as well. Remove the bias and move to the next ring.
+                    pBiasSegment = NULL;
+                    pRing = m_pScheduler->GetNextSchedulingRing(pOwningRing, pRing);
+
+                } // end of while (pRing != NULL) - this loop goes over all rings in the scheduler
+            } // end of for (!fFound && phase <= maxPhase) - this loop goes through all search affinity types
+        } // end of if (!fFound)
+
+        if (fFound)
+        {
+            ScheduleGroupSegmentBase *pSegment = pWorkItem->GetScheduleGroupSegment();
+            SchedulingRing *pRing = pSegment->GetSchedulingRing();
+
+            pSegment->ServiceMark(m_serviceTick);
+
+            bool fAffine = false;
+            if (!pSegment->GetAffinity()._Is_system())
+            {
+                location vpLoc = m_pVirtualProcessor->GetLocation();
+                if (vpLoc._FastVPIntersects(pSegment->GetAffinity()))
+                    fAffine = true;
+            }
+            bool fLocal = pRing == pOwningRing;
+
+            m_pVirtualProcessor->UpdateWorkState(fAffine, fLocal);
+        }
+
+        return fFound;
+    }
+
+    /// <summary>
+    ///     Searches for work within the scheduler according to the cache local (schedule group local) search algorithm for yielding.
+    /// </summary>
+    /// <param name="pWorkItem">
+    ///     If a work item is found, the work item will be returned here.
+    /// </param>
+    /// <param name="pOriginSegment">
+    ///     The segment to bias the search to. The need to prefer localized and prioritized work will often trump this bias.
+    /// </param>
+    /// <param name="fLastPass">
+    ///     An indication as to whether this is a last pass SFW.
+    /// </param>
+    /// <param name="allowableTypes">
+    ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+    ///     can be returned as well as whether the actual work item or only a token should be returned.
+    /// </param>
+    /// <returns>
+    ///     An indication of whether a work item was found or not.
+    /// </returns>
+    bool WorkSearchContext::SearchCacheLocalYield(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes)
+    {
+        bool fFound = false;
+
+        if (PreSearch(pWorkItem))
+            return true;
+
+        ASSERT(pOriginSegment);
+
+        m_serviceTick = platform::__GetTickCount64();
+        m_pScheduler->PeriodicScan(m_serviceTick);
+
+        //
+        // @TODO: This is a temporary patch until we have priority and boosts in the scheduler.  Right now, search for any segment in the locked
+        // FIFO of "priority" segments to see if we need to service someone to avoid livelock.  We also periodically scan to determine whether
+        // groups need to go into this list.
+        //
+
+        if (CheckPriorityList(m_serviceTick))
+        {
+            if (m_pScheduler->HasPriorityObjects())
+            {
+                BoostedObject *pObject = m_pScheduler->GetNextPriorityObject();
+                while (pObject != NULL)
+                {
+                    if (pObject->IsScheduleGroupSegment())
+                    {
+                        ScheduleGroupSegmentBase *pSegment = ScheduleGroupSegmentBase::FromBoostEntry(pObject);
+                        OMTRACE(MTRACE_EVT_PRIORITYPULL, pSegment, NULL, m_pVirtualProcessor, 1);
+                        if (QuickSearchYield(pSegment, pWorkItem, fLastPass, allowableTypes))
+                        {
+                            fFound = true;
+                            break;
+                        }
+                    }
+                    else if (allowableTypes & WorkItem::WorkItemTypeContext)
+                    {
+                        VirtualProcessor *pVProc = VirtualProcessor::FromBoostEntry(pObject);
+                        InternalContextBase *pContext = pVProc->StealLocalRunnableContext();
+                        if (pContext != NULL)
+                        {
+                            *pWorkItem = WorkItem(pContext);
+                            fFound = true;
+                            break;
+                        }
+                    }
+
+                    pObject = m_pScheduler->GetNextPriorityObject();
+                }
+            }
+
+            //
+            // If we found something in a priority segment, we need to mark the V-Proc so that it once again looks for affinitized work
+            // the next time through SFW.
+            //
+            m_pVirtualProcessor->MarkGrabbedPriority();
+        }
+
+        SchedulingRing *pOwningRing = m_pVirtualProcessor->GetOwningRing();
+
+        if (!fFound)
+        {
+            //
+            // Before describing the cache local search algorithm, some definitions to aid in this are in order:
+            //
+            // Work:
+            //     local work      -- Work within a node/ring that a given virtual processor belongs to is considered local work
+            //     foreign work    -- Work within a node/ring that a given virtual processor does *NOT* belong to is considered foreign work
+            //     affine work     -- Work which is placed at a location more specific than the system location is affine work
+            //     non-affine work -- Work which is placed at the system location (or no location) is considered non-affine work
+            //
+            // Virtual Processors:
+            //     rambling   -- a given virtual processor is *rambling* when it is executing foreign work (regardless whether such work is affine to it or not)
+            //     non-affine -- a given virtual processor is *non-affine* when it is executing non-affine work (regardless whether it is rambling or not)
+            //
+            // Virtual processors which are rambling or are executing non-affine work are tracked by the scheduler.  When such virtual processors
+            // exist, notifications will be published whenever affine work or local work
+            //
+
+            //
+            // **IN GENERAL**, we want to find work in the following order of precedence:
+            //
+            // Phase 1: Affine work
+            //       Affine work in our current group (preferring local affine work)
+            //       Local affine (to us) work (in our starting (home) ring)
+            //       Foreign affine (to us) work (in foreign ring segments that match our affinity mask -- such have a segment in our ring by definition)
+            //
+            //       - This phase may be skipped if we are executing non-affine work and have not received an affinity notification from the scheduler.
+            //         Doing so prevents SFW from making a full pass per work item if no affinity has been used.
+            //
+            // Phase 2: Non-affine work
+            //       Non-Affine work in our current group (preferring local work)
+            //       Local non-affine work (in our starting (home ring))
+            //       Foreign non-affine work (in foreign rings).
+            //
+            //       - This phase may *NEVER* be skipped.
+            //
+            // Phase 3: Affine work (non-local)
+            //       Non-local affine (*NOT* to us) work (in foreign ring segments that do not match our affinity mask
+            //
+            //       - This phase may be skipped in theory if we know that there is no affine work in the scheduler.  For a case with no affinity used within
+            //         any scheduling API, this phase is only hit if the scheduler is completely idle.  At idle, performing a pass is likely little additional
+            //         cost to any performance sensitive scenario.  At present, this stage is not skipped for this reason.
+            //
+            // At a very high level, you can consider a cache local search to be making vertical slices through the search space as follows:
+            //
+            //               SR      SR     SR     SR
+            // Contexts      |       |      |      |
+            // Realized      |       |      |      |
+            // Unrealized    v       v      v      v
+            //
+            // where each entry in this matrix is a piece of a schedule group.
+            //
+            // Note that in the last pass of SFW, we cannot skip phases or segments.  Doing so can lead us to deadlock in cases with required dependence
+            // (assumptions on concurrency level).
+            //
+            static const SearchAffinity phaseAffinities[] = { SearchAffineLocal, SearchNonAffine, SearchAffineNotMe };
+            //                                              {       1          ,       0        ,         2         };
+            int startPhaseIndex = (!m_pVirtualProcessor->ExecutingAffine() && !m_pVirtualProcessor->CheckAffinityNotification() && !fLastPass) ? 1 : 0;
+            int maxPhaseIndex = SIZEOF_ARRAY(phaseAffinities) - 1;
+
+            // @TODO_LOC: We need livelock prevention by doing a priority boost on segments that haven't been serviced in "too long".
+
+            bool fLocalCheck = true;
+            for (int phaseIndex = startPhaseIndex; !fFound && phaseIndex <= maxPhaseIndex; ++phaseIndex) // This loop goes through the phases in the phaseAffinity array.
+            {
+                SearchAffinity srchType = phaseAffinities[phaseIndex];
+
+                // At the outset of every pass, we bias to the originating segment/group and the current virtual processor's owning ring.
+                // Note that if we are searching for non-local affine work, we skip the owning ring (by definition, it's local).
+                ScheduleGroupSegmentBase *pBiasSegment = pOriginSegment;
+                SchedulingRing *pRing = pOwningRing;
+
+                while (pRing != NULL)
+                {
+                    if (((allowableTypes & WorkItem::WorkItemTypeMaskAnyUnrealizedChore) &&
+                            SearchCacheLocal_Unrealized(pWorkItem,
+                                                        pRing,
+                                                        pBiasSegment,
+                                                        !!(allowableTypes & WorkItem::WorkItemTypeUnrealizedChore),
+                                                        srchType,
+                                                        allowableTypes,
+                                                        fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeMaskAnyRealizedChore) &&
+                            SearchCacheLocal_Realized(pWorkItem,
+                                                      pRing,
+                                                      pBiasSegment,
+                                                      !!(allowableTypes & WorkItem::WorkItemTypeRealizedChore),
+                                                      srchType,
+                                                      allowableTypes,
+                                                      fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeContext) &&
+                            SearchCacheLocal_Runnables(pWorkItem,
+                                                       pRing,
+                                                       pBiasSegment,
+                                                       fLocalCheck,
+                                                       srchType,
+                                                       allowableTypes,
+                                                       fLastPass)) ||
+
+                        ((allowableTypes & WorkItem::WorkItemTypeContext) && phaseIndex == maxPhaseIndex &&
+                            StealLocalRunnable(pWorkItem, pRing->GetOwningNode(), m_pVirtualProcessor)) ||
+
+                        (fLocalCheck && (allowableTypes & WorkItem::WorkItemTypeContext) &&
+                            GetLocalRunnable(pWorkItem, m_pVirtualProcessor, true)))
+
+                    {
+                        fFound = true;
+                        break;
+                    }
+
+                    // Make sure we only steal from vproc LRCs in the local node once.  This is done in this manner to ensure the odd placement of this within the
+                    // search algorithm.
+                    fLocalCheck = false;
+
+                    // The first time through the loop, not only did we bias to pBiasSegment, but to pStartingRing as well. Remove the bias and move to the next ring.
+                    pBiasSegment = NULL;
+                    pRing = m_pScheduler->GetNextSchedulingRing(pOwningRing, pRing);
+
+                } // end of while (pRing != NULL) - this loop goes over all rings in the scheduler
+            } // end of for (!fFound && phase <= maxPhase) - this loop goes through all search affinity types
+        } // end of if (!fFound)
+
+        if (fFound)
+        {
+            ScheduleGroupSegmentBase *pSegment = pWorkItem->GetScheduleGroupSegment();
+            SchedulingRing *pRing = pSegment->GetSchedulingRing();
+
+            pSegment->ServiceMark(m_serviceTick);
+
+            bool fAffine = pWorkItem->GetScheduleGroupSegment()->GetAffinity()._Is_system();
+            bool fLocal = pRing == pOwningRing;
+
+            m_pVirtualProcessor->UpdateWorkState(fAffine, fLocal);
+        }
+
+        return fFound;
+    }
+}
+}

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SearchAlgorithms.h

@@ -0,0 +1,767 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SearchAlgorithms.h
+//
+// Header file containing definitions for all scheduling algorithms.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+namespace Concurrency
+{
+namespace details
+{
+
+    /// <summary>
+    ///     Variant type representing a work item returned from a search.
+    /// </summary>
+    class WorkItem
+    {
+    public:
+
+        /// <summary>
+        ///     The type of work item.
+        /// </summary>
+        enum WorkItemType
+        {
+            //
+            // Specific types:
+            //
+
+            // Empty work item
+            WorkItemTypeNone = 0x0,
+
+            // Work item is a context
+            WorkItemTypeContext = 0x1,
+
+            // Work item is a realized chore.  Bind() will associate to a context if a context can be allocated
+            WorkItemTypeRealizedChore = 0x2,
+
+            // Work item is an unrealized chore.  Bind() will associate to a context if a context can be allocated
+            WorkItemTypeUnrealizedChore = 0x4,
+
+            // Work item is a token to an realized chore.  ResolveToken() will grab the item if it is still available.
+            WorkItemTypeRealizedChoreToken = 0x8,
+
+            // Work item is a token to an unrealized chore.  ResolveToken() will grab the item if it is still available.
+            WorkItemTypeUnrealizedChoreToken = 0x10,
+
+            //
+            // General Masks:
+            //
+
+            WorkItemTypeMaskAnyRealizedChore = 0xA,
+            WorkItemTypeMaskAnyUnrealizedChore = 0x14
+
+        };
+
+        /// <summary>
+        ///     Default constructor for a work item.
+        /// </summary>
+        WorkItem() :
+            m_type(WorkItemTypeNone),
+            m_pItem(NULL)
+        {
+        }
+
+        /// <summary>
+        ///     Constructs a work item from an internal context.
+        /// </summary>
+        WorkItem(InternalContextBase *pContext);
+
+        /// <summary>
+        ///     Constructs a work item from a realized chore.
+        /// </summary>
+        WorkItem(RealizedChore *pRealizedChore, ScheduleGroupSegmentBase *pSegment) :
+            m_type(WorkItemTypeRealizedChore),
+            m_pSegment(pSegment),
+            m_pRealizedChore(pRealizedChore)
+        {
+        }
+
+        /// <summary>
+        ///    Constructs a work item from an unrealized chore.
+        /// </summary>
+        WorkItem(_UnrealizedChore *pUnrealizedChore, ScheduleGroupSegmentBase *pSegment) :
+            m_type(WorkItemTypeUnrealizedChore),
+            m_pSegment(pSegment),
+            m_pUnrealizedChore(pUnrealizedChore)
+        {
+        }
+
+        /// <summary>
+        ///     Constructs a work item from an unrealized chore token.
+        /// </summary>
+        WorkItem(WorkQueue *pWorkQueue, ScheduleGroupSegmentBase *pSegment) :
+            m_type(WorkItemTypeUnrealizedChoreToken),
+            m_pSegment(pSegment),
+            m_pWorkQueue(pWorkQueue)
+        {
+        }
+
+        /// <summary>
+        ///     Constructs a work item from a realized chore token.
+        /// </summary>
+        WorkItem(ScheduleGroupSegmentBase *pSegment) :
+            m_type(WorkItemTypeRealizedChoreToken),
+            m_pSegment(pSegment),
+            m_pRealizedChore(nullptr)
+        {
+        }
+
+        /// <summary>
+        ///     Transfers reference counts as necessary to inline the given work item on the given context.  This may
+        ///     only be called on a work item that can be inlined (e.g.: an unbound one).
+        /// </summary>
+        /// <param name="pContext">
+        ///     The context that is attempting to inline the work item.
+        /// </param>
+        void TransferReferences(InternalContextBase *pContext);
+
+        /// <summary>
+        ///     Resolves a token to an underlying work item.
+        /// </summary>
+        bool ResolveToken();
+
+        /// <summary>
+        ///     Binds the work item to a context and returns the context.  This may or may not allocate a new context.  Note that
+        ///     act of binding which performs a context allocation will transfer a single count of work to the counter of the new
+        ///     context.
+        /// </summary>
+        InternalContextBase *Bind();
+
+        /// <summary>
+        ///     Binds the work item to the specified context (which is allocated).  This will never allocate a new context.
+        /// </summary>
+        void BindTo(InternalContextBase *pContext);
+
+        /// <summary>
+        ///     Invokes the work item.
+        /// </summary>
+        void Invoke();
+
+        /// <summary>
+        ///     Accessor for type.
+        /// </summary>
+        WorkItemType GetType() const
+        {
+            return m_type;
+        }
+
+        /// <summary>
+        ///     Returns the work item.
+        /// </summary>
+        void *GetItem() const
+        {
+            return m_pItem;
+        }
+
+        /// <summary>
+        ///     Returns whether the work item is a context or not.
+        /// </summary>
+        bool IsContext() const
+        {
+            return (m_type == WorkItemTypeContext);
+        }
+
+        /// <summary>
+        ///     Returns whether the work item is a token or not.
+        /// </summary>
+        bool IsToken() const
+        {
+            return ((m_type & (WorkItemTypeRealizedChoreToken | WorkItemTypeUnrealizedChoreToken)) != 0);
+        }
+
+        /// <summary>
+        ///     Accessor for a context.
+        /// </summary>
+        InternalContextBase *GetContext() const
+        {
+            CONCRT_COREASSERT(m_type == WorkItemTypeContext);
+            return m_pContext;
+        }
+
+        /// <summary>
+        ///     Accessor for a realized chore.
+        /// </summary>
+        RealizedChore *GetRealizedChore() const
+        {
+            CONCRT_COREASSERT(m_type == WorkItemTypeRealizedChore);
+            return m_pRealizedChore;
+        }
+
+        /// <summary>
+        ///     Accessor for an unrealized chore.
+        /// </summary>
+        _UnrealizedChore *GetUnrealizedChore() const
+        {
+            CONCRT_COREASSERT(m_type == WorkItemTypeUnrealizedChore);
+            return m_pUnrealizedChore;
+        }
+
+        /// <summary>
+        ///     Accessor for the schedule group segment.
+        /// </summary>
+        ScheduleGroupSegmentBase *GetScheduleGroupSegment() const
+        {
+            return m_pSegment;
+        }
+
+        /// <summary>
+        ///     Accessor for the schedule group.
+        /// </summary>
+        ScheduleGroupBase *GetScheduleGroup() const;
+
+    private:
+
+        // The type of work item
+        WorkItemType m_type;
+
+        // The schedule group that the work item was found in.
+        ScheduleGroupSegmentBase *m_pSegment{};
+
+        // The work item itself
+        union
+        {
+            void *m_pItem;
+            WorkQueue *m_pWorkQueue;
+            InternalContextBase *m_pContext;
+            RealizedChore *m_pRealizedChore;
+            _UnrealizedChore *m_pUnrealizedChore;
+        };
+
+    };
+
+    /// <summary>
+    ///     A class which tracks iterator state for a search-for-work.  This is generic in terms of search algorithm.
+    /// </summary>
+    class WorkSearchContext
+    {
+    public:
+
+        /// <summary>
+        ///     Describes the search algorithm being utilized.
+        /// </summary>
+        enum Algorithm
+        {
+            AlgorithmNotSet = 0,
+            AlgorithmCacheLocal,
+            AlgorithmFair
+        };
+
+        /// <summary>
+        ///     Describes the type of affinity we are allowed to search for.
+        /// </summary>
+        enum SearchAffinity
+        {
+            // Search for non-affine work within the domain of the search.
+            SearchNonAffine,
+
+            // Search for work which is affine to the search context within the domain of the search.
+            SearchAffineLocal,
+
+            // Search for work which is affine to something OTHER than the search context within the domain of the search.
+            SearchAffineNotMe
+        };
+
+        /// <summary>
+        ///     Constructs a work search context that will be reset later.
+        /// </summary>
+        WorkSearchContext() : m_pVirtualProcessor(NULL), m_pScheduler(NULL), m_pSearchFn(NULL), m_pSearchYieldFn(NULL)
+        {
+        }
+
+        /// <summary>
+        ///     Constructs a work search context (an iterator position for a search algorithm).
+        /// </summary>
+        WorkSearchContext(VirtualProcessor *pVirtualProcessor, Algorithm algorithm)
+        {
+            Reset(pVirtualProcessor, algorithm);
+        }
+
+        /// <summary>
+        ///     Resets the work search context to utilize the specified algorithm at the starting iterator position.
+        /// </summary>
+        /// <param name="pVirtualProcessor">
+        ///     The virtual processor binding the searching.
+        /// </param>
+        /// <param name="algorithm">
+        ///     What algorithm to reset the iterator with.
+        /// </param>
+        void Reset(VirtualProcessor *pVirtualProcessor, Algorithm algorithm);
+
+        /// <summary>
+        ///     Searches from the last iterator position according to the set algorithm.  This can return any type of work
+        ///     item (context, realized chore, or unrealized chore)
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     Upon successful return, the resulting work item is placed here along with information about what group it was found in, etc...
+        /// </param>
+        /// <param name="pOriginSegment">
+        ///     The schedule group segment of the context which is performing the search.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     What type of work items are allowed to be returned.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool Search(WorkItem *pWorkItem,
+                    ScheduleGroupSegmentBase *pOriginSegment,
+                    bool fLastPass = false,
+                    ULONG allowableTypes = WorkItem::WorkItemTypeContext | WorkItem::WorkItemTypeRealizedChore | WorkItem::WorkItemTypeUnrealizedChore)
+        {
+            return (this->*m_pSearchFn)(pWorkItem, pOriginSegment, fLastPass, allowableTypes);
+        }
+
+
+        /// <summary>
+        ///     Searches from the last iterator position according to the set algorithm for a yield.  This can return any type of
+        ///     work item (context, realized chore, or unrealized chore)
+        /// </summary>
+        bool YieldingSearch(WorkItem *pWorkItem,
+                                ScheduleGroupSegmentBase *pOriginSegment,
+                                bool fLastPass = false,
+                                ULONG allowableTypes = WorkItem::WorkItemTypeContext | WorkItem::WorkItemTypeRealizedChore)
+        {
+            return (this->*m_pSearchYieldFn)(pWorkItem, pOriginSegment, fLastPass, allowableTypes);
+        }
+
+    private:
+
+        // **************************************************
+        // Common:
+        //
+
+        /// <summary>
+        ///     Describes where the bias towards certain lists is at within SFW.
+        /// </summary>
+        enum BiasStageType
+        {
+            BiasStageNone,
+            BiasStageFlipLRC,
+            BiasStageSkipLRC
+        };
+
+        // The virtual processor binding the search.
+        VirtualProcessor *m_pVirtualProcessor;
+
+        // The scheduler
+        SchedulerBase *m_pScheduler;
+
+        // The mask ID of the virtual processor binding the search.
+        unsigned int m_maskId{};
+
+        // How many times work has been found in the LRC since the last reset.
+        ULONG m_LRCBias{};
+
+        // The service time stamp
+        ULONGLONG m_serviceTick{};
+
+        // TRANSITION: This goes with real priority...
+        ULONGLONG m_lastPriorityPull{};
+
+        // The search function to utilize.
+        bool (WorkSearchContext::*m_pSearchFn)(WorkItem *pWorkItem,
+                                               ScheduleGroupSegmentBase *pOriginSegment,
+                                               bool fLastPass,
+                                               ULONG allowableTypes);
+
+        // The search function to utilize for yielding.
+        bool (WorkSearchContext::*m_pSearchYieldFn)(WorkItem *pWorkItem,
+                                                    ScheduleGroupSegmentBase *pOriginSegment,
+                                                    bool fLastPass,
+                                                    ULONG allowableTypes);
+
+        //
+        // TRANSITION: This goes with real priority...
+        //
+        bool CheckPriorityList(ULONGLONG serviceTime)
+        {
+            bool fCheck = ((serviceTime - m_lastPriorityPull) > (ULONGLONG)1000);
+            if (fCheck)
+                m_lastPriorityPull = serviceTime;
+
+            return fCheck;
+
+        }
+
+        /// <summary>
+        ///     Performs a quick search of a particular segment.
+        /// </summary>
+        bool QuickSearch(ScheduleGroupSegmentBase *pQCSegment,
+                         WorkItem *pWorkItem,
+                         bool fLastPass,
+                         ULONG allowableTypes);
+
+        /// <summary>
+        ///     Performs a quick yielding search of a particular segment.
+        /// </summary>
+        bool QuickSearchYield(ScheduleGroupSegmentBase *pQCSegment,
+                              WorkItem *pWorkItem,
+                              bool fLastPass,
+                              ULONG allowableTypes);
+
+        /// <summary>
+        ///     Performs a pre-search for any "special" contexts (e.g.: the UMS SUT)
+        /// </summary>
+        bool PreSearch(WorkItem *pWorkItem);
+
+        /// <summary>
+        ///     Steals a local runnable from a virtual processor within the specified node.  Note that this allows a given virtual processor
+        ///     to be skipped.
+        /// </summary>
+        bool StealLocalRunnable(WorkItem *pWorkItem, SchedulingNode *pNode, VirtualProcessor *pSkipVirtualProcessor);
+
+        /// <summary>
+        ///     Steals a local runnable from a virtual processor of any scheduling node other than the specified local node.
+        /// </summary>
+        bool StealForeignLocalRunnable(WorkItem *pWorkItem, SchedulingNode *pLocalNode);
+
+        /// <summary>
+        ///     Gets a local runnable context from the specified virtual processor.
+        /// </summary>
+        bool GetLocalRunnable(WorkItem *pWorkItem, VirtualProcessor *pVirtualProcessor, bool fYieldingSearch);
+
+        /// <summary>
+        ///     Gets a runnable from the specified schedule group segment.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     The schedule group segment in which to look for a runnable context.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether or not a runnable context was found in the segment.
+        /// </returns>
+        bool GetRunnableContext(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment);
+
+        /// <summary>
+        ///     Gets a realized chore from the specified schedule group segment.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     The schedule group segment in which to look for a realized chore.
+        /// </param>
+        /// <param name="fRealWork">
+        ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+        ///     is resolved.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether or not a realized chore was found in the segment.
+        /// </returns>
+        bool GetRealizedChore(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork);
+
+        /// <summary>
+        ///     Gets an unrealized chore from the specified schedule group segment.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     The schedule group segment in which to look for an unrealized chore.
+        /// </param>
+        /// <param name="fForceStealLocalized">
+        ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+        ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+        ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+        /// </param>
+        /// <param name="fRealWork">
+        ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+        ///     is resolved.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether or not an unrealized chore was found in the segment.
+        /// </returns>
+        bool GetUnrealizedChore(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fForceStealLocalized, bool fRealWork);
+
+        /// <summary>
+        ///     Determines if a segment should be skipped given the search parameters and the segment's affinity.
+        /// </summary>
+        /// <param name="pSegment">
+        ///     The segment to query about skipping.
+        /// </param>
+        /// <param name="pSkipSegment">
+        ///     A segment which should be arbitrarily skipped regardless of affinity type.  This parameter can be NULL.
+        /// </param>
+        /// <param name="affinity">
+        ///     The search affinity type to query for.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication as to whether pSegment should be skipped according to the pSkipSegment and affinity parameters.
+        /// </returns>
+        bool SkipSegmentSearch(ScheduleGroupSegmentBase *pSegment, ScheduleGroupSegmentBase *pSkipSegment, SearchAffinity affinity, bool fLastPass);
+
+        /// <summary>
+        ///     Searches the schedule group to which pSegment belongs to find a runnable.  The group is searched for segments according to the specified
+        ///     affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If an appropriate runnable is found, the resulting work item will be placed here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool GetRunnableContextWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, SearchAffinity affinity, bool fLastPass);
+
+        /// <summary>
+        ///     Searches the schedule group to which pSegment belongs to find a realized chore.  The group is searched for segments according to the specified
+        ///     affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If an appropriate realized chore is found, the resulting work item will be placed here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool GetRealizedChoreWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork, SearchAffinity affinity, bool fLastPass);
+
+        /// <summary>
+        ///     Searches the schedule group to which pSegment belongs to find an unrealized chore.  The group is searched for segments according to the
+        ///     specified affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If an appropriate unrealized chore is found, the resulting work item will be placed here.
+        /// </param>
+        /// <param name="pSegment">
+        ///     A segment within the group to search.  This segment has bias within the group if it matches the specified affinity type.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool GetUnrealizedChoreWithinGroup(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pSegment, bool fRealWork, SearchAffinity affinity, bool fLastPass);
+
+        /// <summary>
+        ///     Called on any biased work.
+        /// </summary>
+        void LRCBias()
+        {
+            m_LRCBias++;
+        }
+
+        /// <summary>
+        ///     Resets the local bias counter but not the ring bias counter.
+        /// </summary>
+        void ResetLRCBias()
+        {
+            m_LRCBias = 0;
+        }
+
+        /// <summary>
+        ///     Returns the current stage of local bias.
+        /// </summary>
+        BiasStageType BiasStage()
+        {
+            if (m_LRCBias < 101)
+                return BiasStageNone; // (fwd) Normal --> LRC LIFO
+            else if (m_LRCBias < 127)
+                return BiasStageFlipLRC; // (fwd) Flip LRC --> LRC FIFO
+            else
+                return BiasStageSkipLRC; // (fwd) Skip LRC --> runnables
+        }
+
+        // **************************************************
+        // Cache Local Algorithm:
+        //
+
+        /// <summary>
+        ///     Searches for a runnable within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+        ///     pBiasSegment according to the rules of the search and the requested affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pRing">
+        ///     The scheduling ring to search.
+        /// </param>
+        /// <param name="pBiasSegment">
+        ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+        /// </param>
+        /// <param name="fOtherLocalLRCCheck">
+        ///     Determines whether or not to check other local LRCs in this search.
+        /// </param>
+        /// <param name="affinity">
+        ///     The search affinity type to query for.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+        ///     can be returned as well as whether the actual work item or only a token should be returned.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a runnable was found in the bias segment, group, or the specified ring.
+        /// </returns>
+        bool SearchCacheLocal_Runnables(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                        bool fOtherLocalLRCCheck, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass);
+
+        /// <summary>
+        ///     Searches for a realized chore within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+        ///     pBiasSegment according to the rules of the search and the requested affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pRing">
+        ///     The scheduling ring to search.
+        /// </param>
+        /// <param name="pBiasSegment">
+        ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+        /// </param>
+        /// <param name="fRealWork">
+        ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+        ///     is resolved.
+        /// </param>
+        /// <param name="affinity">
+        ///     The search affinity type to query for.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+        ///     can be returned as well as whether the actual work item or only a token should be returned.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a realized chore was found in the bias segment, group, or the specified ring.
+        /// </returns>
+        bool SearchCacheLocal_Realized(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                       bool fRealWork, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass);
+
+        /// <summary>
+        ///     Searches for an unrealized chore within the specified ring.  Before searching elsewhere, it searches the segment and group specified by
+        ///     pBiasSegment according to the rules of the search and the requested affinity type.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pRing">
+        ///     The scheduling ring to search.
+        /// </param>
+        /// <param name="pBiasSegment">
+        ///     The segment to bias the search to.  This segment and its corresponding group are searched first!
+        /// </param>
+        /// <param name="fRealWork">
+        ///     If true, the actual work item is returned.  If false, a token to the work is returned.  The work is not dequeued until the token
+        ///     is resolved.
+        /// </param>
+        /// <param name="affinity">
+        ///     The search affinity type to query for.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+        ///     can be returned as well as whether the actual work item or only a token should be returned.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether an unrealized chore was found in the bias segment, group, or the specified ring.
+        /// </returns>
+        bool SearchCacheLocal_Unrealized(WorkItem *pWorkItem, SchedulingRing *pRing, ScheduleGroupSegmentBase *pBiasSegment,
+                                         bool fRealWork, SearchAffinity affinity, ULONG allowableTypes, bool fLastPass);
+
+        /// <summary>
+        ///     Searches for work within the scheduler according to the cache local (schedule group local) search algorithm.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pOriginSegment">
+        ///     The segment to bias the search to.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+        ///     can be returned as well as whether the actual work item or only a token should be returned.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool SearchCacheLocal(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes);
+
+        /// <summary>
+        ///     Searches for work within the scheduler according to the cache local (schedule group local) search algorithm for yielding.
+        /// </summary>
+        /// <param name="pWorkItem">
+        ///     If a work item is found, the work item will be returned here.
+        /// </param>
+        /// <param name="pOriginSegment">
+        ///     The segment to bias the search to.
+        /// </param>
+        /// <param name="fLastPass">
+        ///     An indication as to whether this is a last pass SFW.
+        /// </param>
+        /// <param name="allowableTypes">
+        ///     A bitmap of work-types allowed to be returned from the search.  This indicates whether or not runnables, realized chores, or unrealized chores
+        ///     can be returned as well as whether the actual work item or only a token should be returned.
+        /// </param>
+        /// <returns>
+        ///     An indication of whether a work item was found or not.
+        /// </returns>
+        bool SearchCacheLocalYield(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes);
+
+        // **************************************************
+        // Fair Algorithm:
+        //
+
+        /// <summary>
+        ///     Performs a fair search for runnables in the specified ring.
+        /// </summary>
+        bool SearchFair_Runnables(WorkItem *pWorkItem, SchedulingRing *pRing);
+
+        /// <summary>
+        ///     Performs a fair search for realized chores in the specified ring.
+        /// </summary>
+        bool SearchFair_Realized(WorkItem *pWorkItem, SchedulingRing *pRing, bool fRealItem);
+
+        /// <summary>
+        ///     Performs a fair search for unrealized chores in the specified ring.
+        /// </summary>
+        bool SearchFair_Unrealized(WorkItem *pWorkItem, SchedulingRing *pRing, bool fRealItem);
+
+        /// <summary>
+        ///     Performs a fair search for work.
+        /// </summary>
+        bool SearchFair(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes);
+
+        /// <summary>
+        ///     Performs a fair search for work in the yielding case.
+        /// </summary>
+        bool SearchFairYield(WorkItem *pWorkItem, ScheduleGroupSegmentBase *pOriginSegment, bool fLastPass, ULONG allowableTypes);
+
+    };
+
+}
+}

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/StructuredWorkStealingQueue.h

@@ -0,0 +1,414 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// StructuredWorkStealingQueue.h
+//
+// Header file containing the core implementation of the work stealing data structures and algorithms.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     A StructuredWorkStealingQueue is a wait-free, lock-free structure associated with a single
+    ///     thread that can Push and Pop elements. Other threads can do Steal operations
+    ///     on the other end of the StructuredWorkStealingQueue with little contention.
+    /// </summary>
+    template <typename T, typename LOCK=_NonReentrantLock>
+    class StructuredWorkStealingQueue
+    {
+        // A 'StructuredWorkStealingQueue' always runs its code in a single OS thread. We call this the
+        // 'bound' thread. Only the code in the Steal operation can be executed by
+        // other 'foreign' threads that try to steal work.
+        //
+        // The queue is implemented as a lock-free dequeue of arrays. The m_head and m_tail index this
+        // array. To avoid copying elements, the m_head and m_tail index the array modulo
+        // the size of the array. By making this a power of two, we can use a cheap
+        // bit-and operation to take the modulus. The "m_mask" is always equal to the
+        // size of the task array minus one (where the size is a power of two).
+        //
+        // The m_head and m_tail are volatile as they can be updated from different OS threads.
+        // The "m_head" is only updated by foreign threads as they Steal a task from
+        // this queue. By putting a lock in Steal, there is at most one foreign thread
+        // changing m_head at a time. The m_tail is only updated by the bound thread.
+        //
+        // invariants:
+        //   tasks.length is a power of 2
+        //   m_mask == tasks.length-1
+        //   m_head is only written to by foreign threads
+        //   m_tail is only written to by the bound thread
+        //   At most one foreign thread can do a Steal
+        //   All methods except Steal are executed from a single bound thread
+        //   m_tail points to the first unused location
+        //
+        // This work stealing implementation also supports the notion of out-of-order waiting
+        // and out-of-order removal from the bound thread given that it is initialized to do so.
+        // There is additional cost to performing this.
+        //
+
+    public:
+
+        /// <summary>
+        ///     Constructs a new work stealing queue
+        /// </summary>
+        StructuredWorkStealingQueue(LOCK *pLock)
+            : m_head(0),
+            m_tail(0),
+            m_pLock(pLock)
+        {
+            ASSERT(s_initialSize > 1);
+            m_mask = s_initialSize - 1;
+            m_ppTasks = _concrt_new T*[s_initialSize];
+            m_pSlots = _concrt_new typename Mailbox<T>::Slot[s_initialSize];
+            memset(m_ppTasks, 0, s_initialSize * sizeof(T*));
+            ASSERT(m_pLock != NULL);
+        }
+
+        /// <summary>
+        ///     Reinitializes a workqueue to the state essentially equivalent to just after construction.
+        ///     This is used when recycling a workqueue from its ListArray
+        /// </summary>
+        /// <param name="allowOutOfOrder">
+        ///     Indicates whether or not the work stealing queue will allow out of order waiting on the bound thread.
+        ///     Allowing this has additional cost.
+        /// </param>
+        /// <param name="initialSize">
+        ///     Indicates the initially allocated size for the physical work item storage
+        /// </param>
+        void Reinitialize()
+        {
+            m_head = 0;
+            m_tail = 0;
+        }
+
+        //
+        // unlocked count
+        //
+        int Count() const
+        {
+            return (m_tail - m_head);
+        }
+
+        //
+        // unlocked check
+        //
+        bool Empty() const
+        {
+            return (m_tail <= m_head);
+        }
+
+        //
+        // Push/Pop and Steal can be executed interleaved. In particular:
+        // 1) A steal and pop should be careful when there is just one element
+        //    in the queue. This is done by first incrementing the m_head/decrementing the m_tail
+        //    and than checking if it interleaved (m_head > m_tail).
+        // 2) A push and steal can interleave in the sense that a push can overwrite the
+        //    value that is just stolen. To account for this, we check conservatively in
+        //    the push to assume that the size is one less than it actually is.
+
+        /// <summary>
+        ///     Attempts to steal the oldest element in the queue.  This handles potential interleaving with both
+        ///     a Pop and other Steal operations.
+        /// </summary>
+        /// <param name="fForceStealLocalized">
+        ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+        ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+        ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+        /// </param>
+        T* Steal(bool fForceStealLocalized = false)
+        {
+            typename LOCK::_Scoped_lock lock(*m_pLock);
+            return UnlockedSteal(fForceStealLocalized);
+        }
+
+        /// <summary>
+        ///     Must be called under m_pLock->_Acquire/m_pLock->_TryAcquire
+        /// </summary>
+        /// <param name="fForceStealLocalized">
+        ///     Whether to steal the task at the bottom end of the work stealing queue even if it is an affinitized to a location
+        ///     that has active searches. This is set to true on the final SFW pass to ensure a vproc does not deactivate while there
+        ///     are chores higher up in the queue that are un-affinitized and therefore inaccessible via a mailbox.
+        /// </param>
+        T* UnlockedSteal(bool fForceStealLocalized)
+        {
+            while (m_head < m_tail)
+            {
+                int h = m_head;
+
+                //
+                // Do not allow a steal from this work stealing queue if the bottom task was mailed to a location which has active searchers.
+                // This will not block finalization in any way as the last pass SFW will pull the task out of the mailbox regardless of affinity.
+                // We should be careful not to do this if the current context's virtual processor is in the affinity set of the segment.
+                // If not, there could be cases where all virtual processors deactivate, but the scheduler does not shutdown since there are chores
+                // in the queue, even if they have been dequeued via the mailbox.
+                //
+                if(IS_AFFINITIZED_TASK(m_ppTasks[h & m_mask]))
+                {
+                    //
+                    // Skip this workqueue if there are affine searchers and we are not one of them.
+                    //
+                    if (!fForceStealLocalized && m_pSlots[h & m_mask].DeferToAffineSearchers())
+                        return NULL;
+                }
+
+                T *pResult = (T*) _InterlockedExchangePointer((volatile PVOID*) &m_ppTasks[h & m_mask], (PVOID) NULL);
+
+                if (IS_AFFINITIZED_TASK(pResult))
+                {
+                    pResult = STRIP_AFFINITY_INDICATOR(T, pResult);
+
+                    //
+                    // If the task was already executed via a mailbox dequeue, move on and try to steal again.
+                    //
+                    if (!m_pSlots[h & m_mask].Claim())
+                    {
+                        m_head = h + 1;
+                        continue;
+                    }
+                }
+
+                if (pResult != NULL)
+                    m_head = h+1;
+
+                return pResult;
+            }
+
+            return NULL;
+        }
+
+        /// <summary>
+        ///     Attempts to pop the newest element on the work stealing queue.  It may return NULL if there is no such
+        ///     item (either unbalanced push/pop, a chore stolen).  A special constant AFFINITY_EXECUTED is returned
+        //      if the item was executed via a mailbox slot.
+        /// </summary>
+        T* Pop()
+        {
+            int t = m_tail - 1;
+            m_tail = t;
+            T* pResult = (T*) _InterlockedExchangePointer((volatile PVOID*) &m_ppTasks[t & m_mask], (PVOID) NULL);
+            if (pResult == NULL)
+                m_tail = t + 1;
+
+            //
+            // If the task had an associated affinity, we must deal with the possibility that it was already executed by a virtual
+            // processor to which it was affine through a mailbox.
+            //
+            if (IS_AFFINITIZED_TASK(pResult))
+            {
+                pResult = STRIP_AFFINITY_INDICATOR(T, pResult);
+
+                //
+                // If the task was already executed via a mailbox dequeue, return an indication to the caller.
+                //
+                if (!m_pSlots[t & m_mask].Claim())
+                {
+                    return (T*)AFFINITY_EXECUTED;
+                }
+            }
+            return pResult;
+        }
+
+        /// <summary>
+        ///     Pushes an element onto the work stealing queue.
+        /// </summary>
+        void Push(T* element, typename Mailbox<T>::Slot affinitySlot)
+        {
+            int t = m_tail;
+
+            AvoidOverflow(t);
+
+            //
+            // Careful here since we might interleave with Steal.
+            // This is no problem since we just conservatively check if there is
+            // enough space left (t < m_head + size). However, Steal might just have
+            // incremented m_head and we could potentially overwrite the old m_head
+            // entry, so we always leave at least one extra 'buffer' element and
+            // check (m_tail < m_head + size - 1). This also plays nicely with our
+            // initial m_mask of 0, where size is 2^0 == 1, but the tasks array is
+            // still null.
+            //
+            if (t < m_head + m_mask)  // == t < m_head + size - 1
+            {
+                if (!affinitySlot.IsEmpty())
+                {
+                    //
+                    // Flag the element as affinitized.  On popping this element, the box slot must be cleared to prevent
+                    // multiple execution.
+                    //
+                    m_pSlots[t & m_mask] = affinitySlot;
+                    element = ADD_AFFINITY_INDICATOR(T, element);
+                }
+
+                m_ppTasks[t & m_mask] = element;
+                // Only increment once we have initialized the task entry. This is a volatile write and has release semantics on weaker memory models
+                m_tail = t + 1;
+            }
+            else
+                GrowAndPush(element, affinitySlot);
+        }
+
+        /// <summary>
+        ///     Pushes an element onto the work stealing queue.
+        /// </summary>
+        void Push(T* element)
+        {
+            int t = m_tail;
+
+            AvoidOverflow(t);
+
+            //
+            // Careful here since we might interleave with Steal.
+            // This is no problem since we just conservatively check if there is
+            // enough space left (t < m_head + size). However, Steal might just have
+            // incremented m_head and we could potentially overwrite the old m_head
+            // entry, so we always leave at least one extra 'buffer' element and
+            // check (m_tail < m_head + size - 1). This also plays nicely with our
+            // initial m_mask of 0, where size is 2^0 == 1, but the tasks array is
+            // still null.
+            //
+            if (t < m_head + m_mask)  // == t < m_head + size - 1
+            {
+                m_ppTasks[t & m_mask] = element;
+                // Only increment once we have initialized the task entry. This is a volatile write and has release semantics on weaker memory models
+                m_tail = t + 1;
+            }
+            else
+                GrowAndPush(element, typename Mailbox<T>::Slot());
+        }
+
+        /// <summary>
+        ///     Destroys a work stealing queue.
+        /// </summary>
+        ~StructuredWorkStealingQueue()
+        {
+            delete [] m_ppTasks;
+            delete [] m_pSlots;
+        }
+
+    private:
+
+        // The m_head and m_tail are volatile as they can be updated from different OS threads.
+        // The "m_head" is only updated by foreign threads as they Steal a task from
+        // this queue. By putting a lock in Steal, there is at most one foreign thread
+        // changing m_head at a time. The m_tail is only updated by the bound thread.
+        //
+        // invariants:
+        //   tasks.length is a power of 2
+        //   m_mask == tasks.length-1
+        //   m_head is only written to by foreign threads
+        //   m_tail is only written to by the bound thread
+        //   At most one foreign thread can do a Steal
+        //   All methods except Steal are executed from a single bound thread
+        //   m_tail points to the first unused location
+        //
+
+        static const int s_initialSize = 64;  // must be a power of 2
+
+        volatile int m_head;                  // only updated by Steal
+        volatile int m_tail;                  // only updated by Push and Pop
+
+        int m_mask;                           // the m_mask for taking modulus
+
+        T**  m_ppTasks;                       // the array of tasks
+        typename Mailbox<T>::Slot *m_pSlots;  // the array of side-band affinity structures
+
+        LOCK *m_pLock;
+
+        // private helpers
+
+        T* LockedPop(int t)
+        {
+            typename LOCK::_Scoped_lock lock(*m_pLock);
+            T* pResult = NULL;
+
+            if (m_head <= t)
+                pResult = m_ppTasks[t & m_mask];
+            else
+                m_tail = t + 1;
+            if (m_tail <= m_head)
+                m_head = m_tail = 0;
+
+            return pResult;
+        }
+
+        void GrowAndPush(T* element, typename Mailbox<T>::Slot affinitySlot)
+        {
+            // We're full; expand the queue by doubling its size.
+            int newLength = (m_mask + 1) << 1;
+            T** ppNewTasks = _concrt_new T*[newLength];
+            T** ppOldTasks = m_ppTasks;
+
+            typename Mailbox<T>::Slot *pNewSlots = _concrt_new typename Mailbox<T>::Slot[newLength];
+            typename Mailbox<T>::Slot *pOldSlots = m_pSlots;
+
+            {//for lock scope to exclude the delete[]
+                typename LOCK::_Scoped_lock lock(*m_pLock);
+
+                int t = m_tail;
+                int h = m_head;
+                int count = Count();
+
+                _Analysis_assume_(newLength > count); // Guaranteed because we're doubling the size.
+
+                for (int i = 0; i < count; i++)
+                {
+                    ppNewTasks[i] = m_ppTasks[(i + h) & m_mask];
+                    pNewSlots[i] = m_pSlots[(i + h) & m_mask];
+                }
+
+                memset(ppNewTasks + count, 0, (newLength - count) * sizeof(T*));
+
+                // Reset the field values.
+                m_ppTasks = ppNewTasks;
+                m_pSlots = pNewSlots;
+                m_head = 0;
+                t = count;
+                m_mask = newLength - 1;
+
+                if (!affinitySlot.IsEmpty())
+                {
+                    //
+                    // Flag the element as affinitized.  On popping this element, the box slot must be cleared to prevent
+                    // multiple execution.
+                    //
+                    m_pSlots[t & m_mask] = affinitySlot;
+                    element = ADD_AFFINITY_INDICATOR(T, element);
+                }
+
+                m_ppTasks[t & m_mask] = element;
+                m_tail = t + 1;
+            }//end: lock scope
+
+            delete[] ppOldTasks;
+            delete[] pOldSlots;
+        }
+
+        void AvoidOverflow(int& t) {
+            // Balanced calls to Steal() and Push() will increment m_head and m_tail forever.
+            // To avoid integer overflow, we need to reduce m_head and m_tail simultaneously,
+            // preserving their modulo-indexing behavior and relative distance.
+
+            if (t + m_mask == INT_MAX) { // begin: lock scope
+                typename LOCK::_Scoped_lock lock(*m_pLock);
+
+                int h = m_head;
+                const int original_distance = t - h;
+
+                h &= m_mask;
+                t = h + original_distance;
+
+                m_head = h;
+                m_tail = t;
+            } // end: lock scope
+        }
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SubAllocator.cpp

@@ -0,0 +1,379 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SubAllocator.cpp
+//
+// Implementation of ConcRT sub allocator
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+/// <summary>
+///     Allocates a block of memory of the size specified.
+/// </summary>
+/// <param name="numBytes">
+///     Number of bytes to allocate.
+/// </param>
+/// <returns>
+///     A pointer to newly allocated memory.
+/// </returns>
+_CONCRTIMP void* Alloc(size_t numBytes)
+{
+    if (numBytes > MAXINT_PTR)
+    {
+        throw std::bad_alloc();
+    }
+
+    return SchedulerBase::CurrentContext()->Alloc(numBytes);
+}
+
+/// <summary>
+///     Frees a block of memory previously allocated by the Alloc API.
+/// </summary>
+/// <param name="pAllocation">
+///     A pointer to an allocation previously allocated by Alloc. If pAllocation is NULL, the API will ignore it, and return
+///     immediately.
+/// </param>
+_Use_decl_annotations_
+_CONCRTIMP void Free(void * pAllocation)
+{
+    if (pAllocation == NULL)
+    {
+        return;
+    }
+    SchedulerBase::CurrentContext()->Free(pAllocation);
+}
+
+namespace details
+{
+    //
+    // Define static variables.
+    //
+
+#if defined(_DEBUG)
+
+    // Debug patterns to fill allocated blocks (borrowed from dbgheap.c)
+
+    static const unsigned char _bNoMansLandFill = 0xFD;   /* fill no-man's land with this */
+    static const unsigned char _bAlignLandFill  = 0xED;   /* fill no-man's land for aligned routines */
+    static const unsigned char _bDeadLandFill   = 0xDD;   /* fill free objects with this */
+    static const unsigned char _bCleanLandFill  = 0xCD;   /* fill new objects with this */
+#endif
+
+#ifdef _WIN64
+    // This supports the same number of buckets and bucket sizes as the LFH heap upto 8192 bytes, i.e., 96 buckets.
+    const int SubAllocator::s_bucketSizes[SubAllocator::s_numBuckets] = {
+    /* granularity -  16 */  16,   32,   48,   64,   80,   96,   112,  128,  144,  160,  176,  192,  208,  224,  240,  256, // sizeClass 0, blockUnits 1 - 16
+    /* granularity -  16 */  272,  288,  304,  320,  336,  352,  368,  384,  400,  416,  432,  448,  464,  480,  496,  512, // sizeClass 0, blockUnits 17 - 32
+    /* granularity -  32 */  544,  576,  608,  640,  672,  704,  736,  768,  800,  832,  864,  896,  928,  960,  992,  1024,// sizeClass 1, blockUnits 33 - 64
+    /* granularity -  64 */  1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 1792, 1856, 1920, 1984, 2048,// sizeClass 2, blockUnits 65 - 128
+    /* granularity - 128 */  2176, 2304, 2432, 2560, 2688, 2816, 2944, 3072, 3200, 3328, 3456, 3584, 3712, 3840, 3968, 4096,// sizeClass 3, blockUnits 129 - 256
+    /* granularity - 256 */  4352, 4608, 4864, 5120, 5376, 5632, 5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680, 7936, 8192,// sizeClass 4, blockUnits 257 - 512
+    };
+
+    // A number such that 2 ^ GranularityShift = Granularity.
+    const int SubAllocator::GranularityShift = 4;
+
+    // The allocation size supported by the largest bucket.
+    const int SubAllocator::MaxAllocationSize = 8192;
+
+#else
+
+    // This supports the same number of buckets and bucket sizes as the LFH heap upto 4096 bytes, i.e., 96 buckets.
+    const int SubAllocator::s_bucketSizes[SubAllocator::s_numBuckets] = {
+    /* granularity -   8 */  8,    16,   24,   32,   40,   48,   56,   64,   72,   80,   88,   96,   104,  112,  120,  128, // sizeClass 0, blockUnits 1 - 16
+    /* granularity -   8 */  136,  144,  152,  160,  168,  176,  184,  192,  200,  208,  216,  224,  232,  240,  248,  256, // sizeClass 0, blockUnits 17 - 32
+    /* granularity -  16 */  272,  288,  304,  320,  336,  352,  368,  384,  400,  416,  432,  448,  464,  480,  496,  512, // sizeClass 1, blockUnits 33 - 64
+    /* granularity -  32 */  544,  576,  608,  640,  672,  704,  736,  768,  800,  832,  864,  896,  928,  960,  992,  1024,// sizeClass 2, blockUnits 65 - 128
+    /* granularity -  64 */  1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 1792, 1856, 1920, 1984, 2048,// sizeClass 3, blockUnits 129 - 256
+    /* granularity - 128 */  2176, 2304, 2432, 2560, 2688, 2816, 2944, 3072, 3200, 3328, 3456, 3584, 3712, 3840, 3968, 4096 // sizeClass 4, blockUnits 257 - 512
+    };
+
+    // A number such that 2 ^ GranularityShift = Granularity.
+    const int SubAllocator::GranularityShift = 3;
+
+    // The allocation size supported by the largest bucket.
+    const int SubAllocator::MaxAllocationSize = 4096;
+#endif
+
+    /// <summary>
+    ///     Returns an index into the array of allocator buckets for this sub allocator. The allocation size of the
+    ///     bucket is guaranteed to satisfy numBytes.
+    /// </summary>
+    /// <param name="numBytes">
+    ///     The size of the allocation. This is what the user requested plus space for the ConcRT allocator header.
+    /// </param>
+    /// <returns>
+    ///     An index into the array of allocator buckets such that.s_bucketSizes[returnedBucketIndex] >= numBytes
+    /// </returns>
+    int SubAllocator::GetBucketIndex(size_t numBytes)
+    {
+        static const int GranularityMask = (1 << GranularityShift) - 1;
+
+        int bucketIndex = -1;
+        size_t allocationSize = (size_t) (((ULONG_PTR)numBytes + GranularityMask) & ~((ULONG_PTR)GranularityMask));
+
+        if (allocationSize > MaxAllocationSize)
+        {
+            // We are unable to satisfy this allocation by an allocator bucket. It should be forwarded to the LFH heap.
+            return bucketIndex;
+        }
+
+        int blockUnits = (int)(allocationSize >> GranularityShift);
+
+        // blockUnits is the number of Granularity size chunks that make up the allocationSize. A blockUnit of 1 is satisfied
+        // by allocator bucket 0. We need to find the index of the bucket that holds the minimum sized allocation that will
+        // satisfy allocationSize.
+        ASSERT(blockUnits > 0);
+
+        // Detect if the allocation will fall within buckets 0 - 31
+        if (blockUnits <= 32)
+        {
+            bucketIndex = blockUnits - 1;
+        }
+        else
+        {
+            int sizeClass = 5; // Add 1 << 5 = 32
+
+            while ((blockUnits >> sizeClass) > 0)
+            {
+                sizeClass += 1;
+            }
+
+            sizeClass -= 5;
+
+            ASSERT(sizeClass > 0);
+
+            // Round blockUnits up to the block unit granularity of the size class.
+            int sizeClassMask = (1 << sizeClass) - 1;
+            blockUnits = (int) (((ULONG_PTR)blockUnits + sizeClassMask) & ~((ULONG_PTR)sizeClassMask));
+
+            bucketIndex = (sizeClass << 4) + (blockUnits >> sizeClass) - 1;
+        }
+
+        ASSERT(allocationSize <= (size_t)s_bucketSizes[bucketIndex]);
+        ASSERT(bucketIndex == 0 || allocationSize > (size_t)s_bucketSizes[bucketIndex - 1]);
+
+        return bucketIndex;
+    }
+
+    /// <summary>
+    ///     Allocates a block of memory of the size specified.
+    /// </summary>
+    /// <param name="numBytes">
+    ///     Number of bytes to allocate.
+    /// </param>
+    /// <returns>
+    ///     A pointer to newly allocated memory.
+    /// </returns>
+    void* SubAllocator::Alloc(size_t numBytes)
+    {
+        AllocationEntry* pAllocationEntry = NULL;
+        size_t allocationSize = numBytes + sizeof(AllocationEntry);
+
+        int bucketIndex = GetBucketIndex(allocationSize);
+
+        if (bucketIndex != -1)
+        {
+            ASSERT(bucketIndex < sizeof(s_bucketSizes));
+            pAllocationEntry = m_buckets[bucketIndex].Alloc();
+
+#if defined(_DEBUG)
+            if (pAllocationEntry != NULL)
+            {
+                InitAndCheckBlockOnAlloc(pAllocationEntry, s_bucketSizes[bucketIndex]);
+            }
+#endif
+
+        }
+
+        if (pAllocationEntry == NULL)
+        {
+            // We need to allocate memory from the CRT heap since either the bucket was empty,
+            // or the size is not one the allocator caches.
+            pAllocationEntry = (AllocationEntry*) _concrt_new char[bucketIndex == -1 ? allocationSize : s_bucketSizes[bucketIndex]];
+        }
+
+        ASSERT(pAllocationEntry != NULL);
+        pAllocationEntry->m_bucketIndex = (ULONG_PTR)Security::EncodePointer((PVOID)(intptr_t)bucketIndex);
+
+        return (void*)(pAllocationEntry + 1);
+    }
+
+    /// <summary>
+    ///     Frees a block of memory previously allocated by the Alloc API.
+    /// </summary>
+    /// <param name="pAllocation">
+    ///     A pointer to an allocation previously allocated by Alloc.
+    /// </param>
+    void SubAllocator::Free(void* pAllocation)
+    {
+        AllocationEntry* pAllocationEntry = (AllocationEntry*)pAllocation - 1;
+        // Disable data truncation warning as only lower 32-bits are needed.
+        #pragma warning(push)
+        #pragma warning(disable: 4302)
+        int bucketIndex = (int)(intptr_t)Security::DecodePointer((PVOID)pAllocationEntry->m_bucketIndex);
+        #pragma warning(pop)
+
+        ASSERT((bucketIndex == -1) || bucketIndex < sizeof(s_bucketSizes));
+
+        if ((bucketIndex == -1) || !m_buckets[bucketIndex].Free(pAllocationEntry))
+        {
+            delete [] (char*)pAllocationEntry;
+        }
+#if defined(_DEBUG)
+        else
+        {
+            InitAndCheckBlockOnFree(pAllocationEntry, s_bucketSizes[bucketIndex]);
+        }
+#endif
+
+    }
+
+    /// <summary>
+    ///     A static allocation API that allocates directly from the CRT heap, and encodes the bucket id in the allocation,
+    ///     based on the size of the block. This is used by callers that are unable to get access to a suballocator at
+    ///     the time they are allocating memory.
+    /// </summary>
+    void* SubAllocator::StaticAlloc(size_t numBytes)
+    {
+        AllocationEntry* pAllocationEntry = NULL;
+        size_t allocationSize = numBytes + sizeof(AllocationEntry);
+
+        int bucketIndex = GetBucketIndex(allocationSize);
+        pAllocationEntry = (AllocationEntry*) _concrt_new char[bucketIndex == -1 ? allocationSize : s_bucketSizes[bucketIndex]];
+
+        ASSERT(pAllocationEntry != NULL);
+        pAllocationEntry->m_bucketIndex = (ULONG_PTR)Security::EncodePointer((PVOID)(intptr_t)bucketIndex);
+
+        return (void*)(pAllocationEntry + 1);
+    }
+
+#if defined(_DEBUG)
+    /// <summary>
+    ///     Initialize a block allocated from the freelist. Perform debug validation on the block to
+    ///     detect user errors.
+    /// </summary>
+    bool SubAllocator::InitAndCheckBlockOnAlloc(AllocationEntry *pAllocationEntry, size_t numBytes)
+    {
+        // Validate the pointer
+        ASSERT(_CrtIsValidHeapPointer((const void *)pAllocationEntry));
+
+        unsigned char * userData = (unsigned char *)(pAllocationEntry + 1);
+
+        ASSERT(numBytes > sizeof(AllocationEntry));
+        size_t userNumBytes = numBytes - sizeof(AllocationEntry);
+
+        // Ensure that the free block has not been overwritten.
+        ASSERT(CheckBytes(userData, _bDeadLandFill, userNumBytes));
+
+        // Initialize the new block
+        memset((void *)userData, _bCleanLandFill, userNumBytes);
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Initialize a block that is added to the freelist. Perform debug validation on the block to
+    ///     detect user errors.
+    /// </summary>
+    bool SubAllocator::InitAndCheckBlockOnFree(AllocationEntry *pAllocationEntry, size_t numBytes)
+    {
+        // Validate the pointer.
+        ASSERT(_CrtIsValidHeapPointer((const void *)pAllocationEntry));
+
+        ASSERT(numBytes > sizeof(AllocationEntry));
+        // Initialize the free block
+        memset((void *)(pAllocationEntry + 1), _bDeadLandFill, (numBytes - sizeof(AllocationEntry)));
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Helper routine that checks where the given block is filled with
+    ///     the given pattern.
+    /// </summary>
+    bool SubAllocator::CheckBytes(unsigned char * pBlock, unsigned char bCheck, size_t numBytes)
+    {
+        while (numBytes--)
+        {
+            if (*pBlock++ != bCheck)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+#endif
+
+    /// <summary>
+    ///     Constructs an allocator bucket.
+    /// <summary>
+    AllocatorBucket::AllocatorBucket() : m_depth(0)
+    {
+        m_pHead = (AllocationEntry*)Security::EncodePointer(NULL);
+    }
+
+    /// <summary>
+    ///     Returns an allocation from the bucket if it is non-empty, and NULL if it is empty.
+    /// </summary>
+    AllocationEntry* AllocatorBucket::Alloc()
+    {
+        AllocationEntry* pAllocationEntry = (AllocationEntry*)Security::DecodePointer(m_pHead);
+
+        if (pAllocationEntry != NULL)
+        {
+            ASSERT(m_depth > 0);
+            m_pHead = pAllocationEntry->m_pNext;
+            --m_depth;
+        }
+
+        return pAllocationEntry;
+    }
+
+    /// <summary>
+    ///     Adds the block to the bucket and returns true if the maximum depth is not reached.
+    ///     If the bucket is 'full', it returns false, and the caller is responsible for freeing
+    ///     the block to the CRT heap.
+    /// </summary>
+    bool AllocatorBucket::Free(AllocationEntry* pAllocation)
+    {
+        if (m_depth < s_maxBucketDepth)
+        {
+            pAllocation->m_pNext = m_pHead;
+            m_pHead = (AllocationEntry*)Security::EncodePointer(pAllocation);
+            ++m_depth;
+
+            ASSERT(m_depth <= s_maxBucketDepth);
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Destroys an allocator bucket.
+    /// </summary>
+    AllocatorBucket::~AllocatorBucket()
+    {
+        while (m_depth != 0)
+        {
+            AllocationEntry * pAllocationEntry = (AllocationEntry*)Security::DecodePointer(m_pHead);
+            ASSERT(pAllocationEntry != NULL);
+
+            m_pHead = pAllocationEntry->m_pNext;
+            delete [] (char*)pAllocationEntry;
+
+            --m_depth;
+        }
+    }
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/SubAllocator.h

@@ -0,0 +1,200 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// SubAllocator.h
+//
+// Class definition for the ConcRT sub allocator.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#pragma once
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Each allocation via the sub allocator has an AllocationEntry header. All we need the allocation entry
+    ///     for, is to tell us the id of the bucket, which indicates the size of the allocation. However, the size
+    ///     of the header is pointer size - since we want to align the user's allocation.
+    /// </summary>
+    union AllocationEntry
+    {
+        // The index to the bucket in the suballocator, that this entry belongs to.
+        ULONG_PTR m_bucketIndex;
+
+        // Pointer to the next allocation in the bucket. This is used to chain allocations in the bucket, and we
+        // do not require a lock since only one thread is guaranteed to be touching the suballocator at a time.
+        AllocationEntry* m_pNext;
+    };
+
+    // A bucket that stores a particular size memory block. A SubAllocator has several allocator buckets.
+    class AllocatorBucket
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs an allocator bucket.
+        /// <summary>
+        AllocatorBucket();
+
+        /// <summary>
+        ///     Destroys an allocator bucket.
+        /// </summary>
+        ~AllocatorBucket();
+
+        /// <summary>
+        ///     Returns an allocation from the bucket if it is non-empty, and NULL if it is empty.
+        /// </summary>
+        AllocationEntry* Alloc();
+
+        /// <summary>
+        ///     Adds the block to the bucket and returns true if the maximum depth is not reached.
+        ///     If the bucket is 'full', it returns false, and the caller is responsible for freeing
+        ///     the block to the CRT heap.
+        /// </summary>
+        bool Free(AllocationEntry* pAllocation);
+
+    private:
+
+        // The current depth of the bucket.
+        int m_depth;
+
+        // The head of the free block list.
+        AllocationEntry* m_pHead;
+
+        // The maximum number of allocations the sub allocator will cache per bucket.
+        static const int s_maxBucketDepth = 32;
+    };
+
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    class SubAllocator
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a suballocator.
+        /// </summary>
+        SubAllocator() :
+            m_fExternalAllocator(false)
+        {
+        }
+
+        /// <summary>
+        ///     Allocates a block of memory of the size specified.
+        /// </summary>
+        /// <param name="numBytes">
+        ///     Number of bytes to allocate.
+        /// </param>
+        /// <returns>
+        ///     A pointer to newly allocated memory.
+        /// </returns>
+        void* Alloc(size_t numBytes);
+
+        /// <summary>
+        ///     Frees a block of memory previously allocated by the Alloc API.
+        /// </summary>
+        /// <param name="pAllocation">
+        ///     A pointer to an allocation previously allocated by Alloc.
+        /// </param>
+        void Free(void* pAllocation);
+
+        /// <summary>
+        ///     A static allocation API that allocates directly from the CRT heap, and encodes the bucket id in the allocation,
+        ///     based on the size of the block. This is used by callers that are unable to get access to a suballocator at
+        ///     the time they are allocating memory.
+        /// </summary>
+        static void* StaticAlloc(size_t numBytes);
+
+        /// <summary>
+        ///     A static free API that frees directly to the CRT heap. This is used by callers that are unable to get access
+        ///     to a suballocator at the time they are freeing memory.
+        /// </summary>
+        static void StaticFree(void* pAllocation)
+        {
+            delete [] (char*) ((AllocationEntry*)pAllocation - 1);
+        }
+
+        /// <summary>
+        ///     Returns an index into the array of allocator buckets for this sub allocator. The allocation size of the
+        ///     bucket is guaranteed to satisfy numBytes.
+        /// </summary>
+        /// <param name="numBytes">
+        ///     The size of the allocation. This is what the user requested plus space for the ConcRT allocator header.
+        /// </param>
+        /// <returns>
+        ///     An index into the array of allocator buckets such that.s_bucketSizes[returnedBucketIndex] >= numBytes
+        /// </returns>
+        static int GetBucketIndex(size_t numBytes);
+
+        /// <summary>
+        ///     Every time an allocator is reused, this flag is set to denote whether it is one out of the 'fixed pool' - the set
+        ///     of allocators that are used for external contexts.
+        /// </summary>
+        void SetExternalAllocatorFlag(bool flag) { m_fExternalAllocator = flag; }
+
+        /// <summary>
+        ///     Returns true, if this allocator is assigned to, or was last assigned to an external context.
+        /// </summary>
+        bool IsExternalAllocator() { return m_fExternalAllocator; }
+
+    private:
+
+        // private methods
+
+#if defined(_DEBUG)
+
+        /// <summary>
+        ///     Initialize a block allocated from the freelist. Perform debug validation on the block to
+        ///     detect user errors.
+        /// </summary>
+        bool InitAndCheckBlockOnAlloc(AllocationEntry *pAllocationEntry, size_t numBytes);
+
+        /// <summary>
+        ///     Initialize a block that is added to the freelist. Perform debug validation on the block to
+        ///     detect user errors.
+        /// </summary>
+        bool InitAndCheckBlockOnFree(AllocationEntry *pAllocationEntry, size_t numBytes);
+
+        /// <summary>
+        ///     Helper routine that checks where the given block is filled with
+        ///     the given pattern.
+        /// </summary>
+        bool CheckBytes(unsigned char * pBlock, unsigned char bCheck, size_t numBytes);
+#endif
+
+        // private member variables
+
+        friend class SchedulerBase;
+        template <class T> friend class LockFreeStack;
+
+        // Entry for freelist of allocators
+        SLIST_ENTRY m_slNext{};
+
+        // The total number of buckets.
+        static const int s_numBuckets = 96;
+
+        // The array of buckets that holds memory for allocation.
+        AllocatorBucket m_buckets[s_numBuckets];
+
+        // This flag is set to true, when it this suballocator is handed to a caller that invoked GetSubAllocator with an argument
+        // of 'true'.
+        bool m_fExternalAllocator;
+
+        // An array that holds the bucket sizes.
+        static const int s_bucketSizes[s_numBuckets];
+
+        // A number such that 2 ^ GranularityShift = the minimum granularity of the allocation buckets.
+        static const int GranularityShift;
+
+        // The allocation size supported by the largest bucket.
+        static const int MaxAllocationSize;
+    };
+#pragma warning(pop)
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/TaskCollection.h

@@ -0,0 +1,241 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// TaskCollection.h
+//
+// Miscellaneous internal support structure definitions for a task collection
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+//
+// The amount that we resize the task stack by per alloc.
+//
+#define TASK_STACK_GROWTH_SIZE 8
+
+//
+// The number of chores that we cap the task stack at. If after this many tasks are pushed, another is -- it cannot
+// be inlined and will cause performance penalty for out-of-order WSQ utilization.
+//
+#define TASK_STACK_SIZE_CAP 1024
+
+// **************************************************************************
+// The phases of task collection cancellation (particularly for unstructured task collections).
+// **************************************************************************
+
+//
+// The exit status mask (indicating which portion actively indicates status)
+//
+#define EXIT_CANCELLATION_MASK 0x3FFFFFFF
+
+//
+// Indicates that an exception has happened and while cancellation may proceed in due course, the end result should
+// be a thrown exception.
+//
+#define EXIT_STATUS_FLAG_EXCEPTION_RAISED 0x80000000
+
+//
+// Indicates that the cancellation exception was thrown because cancellation was detected. The phases of cancellation are defined below.
+//
+#define EXIT_STATUS_FLAG_CANCELLATION_RAISED 0x40000000
+
+//
+// Indicates that cancel has started on the task collection.
+//
+#define EXIT_STATUS_START_CANCEL 0x00000001
+
+// **************************************************************************
+// Execution status meanings: Execution status is used for cancellation of the original task collection and its direct aliases
+// **************************************************************************
+
+//
+// The task collection is in clear state -- it's not inlined, it's not canceled, etc...
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_CLEAR 0
+
+//
+// The task collection is inlined.
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_INLINE 1
+
+//
+// The task collection's cancellation for this alias was deferred because it was not inline.
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_CANCEL_DEFERRED 3
+
+//
+// The cancellation is complete on the arbitrary thread.
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_CANCEL_COMPLETE 4
+
+//
+// The task collection is inlined and about to wait for stolen chores yet the task stack has overflowed. This requires
+// extra care during cancellation.
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_INLINE_WAIT_WITH_OVERFLOW_STACK 5   // 4 | TASKCOLLECTION_EXECUTION_STATUS_INLINE
+
+//
+// The task collection is inlined and a cancellation is in progress some arbitrary thread.
+//
+#define TASKCOLLECTION_EXECUTION_STATUS_INLINE_CANCEL_IN_PROGRESS 9         // 8 | TASKCOLLECTION_EXECUTION_STATUS_INLINE
+
+// **************************************************************************
+// Task collection flags:
+// **************************************************************************
+
+//
+// This is an indirect alias.
+//
+#define TASKCOLLECTIONFLAG_ALIAS_IS_INDIRECT 1
+
+//
+// The entity involved in aliasing which views this flag is responsible for cleaning up the alias.
+//
+#define TASKCOLLECTIONFLAG_ALIAS_FREE_ON_VIEW 2
+
+// **************************************************************************
+// Related flags:
+// **************************************************************************
+
+//
+// The bit indicating that this pointer is a registration rather than a token
+//
+#define TASKCOLLECTIONFLAG_POINTER_IS_REGISTRATION 1
+
+// **************************************************************************
+// Class definitions:
+// **************************************************************************
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     This class is an *INTERNAL* structure which will retain specific optimizations to keeping track
+    ///     of tasks associated with an unstructured task collection.
+    /// </summary>
+    class TaskStack
+    {
+    public:
+
+        /// <summary>
+        ///     Constructs a new task stack
+        /// </summary>
+        TaskStack() : m_stackSize(0), m_stackPtr(0), m_pStack(NULL), m_fOverflow(false)
+        {
+        }
+
+        /// <summary>
+        ///     Destroys a task stack
+        /// </summary>
+        ~TaskStack();
+
+        /// <summary>
+        ///     Pushes an element onto the task stack. Returns a bool as to whether this could happen or not. The only
+        ///     possible error here is out of memory.
+        /// </summary>
+        /// <param name="taskCookie">
+        ///     The task cookie to push onto the stack
+        /// </param>
+        /// <returns>
+        ///     An indication of whether the stack cap was reached.
+        /// </returns>
+        bool Push(int taskCookie);
+
+        /// <summary>
+        ///     Pops an element from the task stack.
+        /// </summary>
+        /// <returns>
+        ///     The element
+        /// </returns>
+        int Pop();
+
+        /// </summary>
+        ///     Returns an indication of whether or not the stack is empty.
+        /// </summary>
+        bool IsEmpty() const;
+
+        /// <summary>
+        ///     Clears out everything on the stack. Does *NOT* reset the overflow flag.
+        /// </summary>
+        void Clear();
+
+        /// <summary>
+        ///     Resets the overflow flag.
+        /// </summary>
+        void ResetOverflow()
+        {
+            m_fOverflow = false;
+        }
+
+        /// <summary>
+        ///     An indication if the stack overflowed (was pushed beyond the cap).
+        /// </summary>
+        bool Overflow() const
+        {
+            return m_fOverflow;
+        }
+
+    private:
+
+        int m_stackSize;
+        int m_stackPtr;
+        int *m_pStack;
+        bool m_fOverflow;
+    };
+
+#define EVENT_UNSIGNALED ((void*) 0)
+#define EVENT_SIGNALED ((void*) 1)
+
+    /// <summary>
+    ///     A single fire (non-resettable) event supporting a single waiter.
+    /// </summary>
+    class StructuredEvent
+    {
+
+    public:
+
+        /// <summary>
+        ///     Constructs a new structured event.
+        /// </summary>
+        StructuredEvent()
+            : m_ptr(EVENT_UNSIGNALED)
+        {
+        }
+
+        /// <summary>
+        ///     Waits until the event is signaled (via some other context calling Set())
+        /// </summary>
+        void Wait();
+
+        /// <summary>
+        ///     Set the event as signaled, and unblock any other contexts waiting on the event.
+        /// </summary>
+        void Set();
+
+    private:
+        void * volatile m_ptr;
+    };
+
+    /// <summary>
+    ///     Context record for WSQ sweeps.
+    /// </summary>
+    struct SweeperContext
+    {
+        /// <summary>
+        ///     Constructs a new sweeper context.
+        /// </summary>
+        SweeperContext(_TaskCollection *pTaskCollection) :
+            m_pTaskCollection(pTaskCollection),
+            m_sweptChores(0)
+        {
+        }
+
+        _TaskCollection *m_pTaskCollection;
+        unsigned int m_sweptChores;
+    };
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/TaskCollectionBase.cpp

@@ -0,0 +1,236 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// TaskCollectionBase.cpp
+//
+// General abstract collection of work counting / eventing implementation
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+    /// <summary>
+    ///     Called when an exception is raised on a chore on a given task collection, this makes a determination of what to do with the exception
+    ///     and stores it for potential transport back to the thread performing a join on a task collection.
+    /// </summary>
+    void _TaskCollectionBase::_RaisedException()
+    {
+        //
+        // Current strategy is that the first exception in is kept and rethrown.  We may update this in the future.
+        //
+        void * _OldStatus = _M_pException;
+        for (;;)
+        {
+            //
+            // We always overwrite the cancel exception being here.  Everything else is "more important".
+            //
+            std::exception_ptr *_pException = (std::exception_ptr *)((size_t)_OldStatus & ~_S_cancelBitsMask);
+            if (_pException != NULL && (size_t)_pException != _S_cancelException)
+                return;
+
+            //
+            // Maintain the lower bit as a cancel status flag to determine where to stop a cancellation.
+            //
+            size_t _cancelStatus = ((size_t)_OldStatus & _S_cancelBitsMask);
+
+            void * _XchgStatus = _InterlockedCompareExchangePointer((void * volatile *) &_M_pException, (void *) (_S_nonNull | _cancelStatus), _OldStatus);
+            if (_XchgStatus == _OldStatus)
+                break;
+
+            _OldStatus = _XchgStatus;
+        }
+
+        //
+        // Note that this is safe as this will only be called on a chore executing on the collection; therefore it will not be touched by the forking
+        // thread until after we "_CountUp" which comes after this.
+        //
+        void *_pExc = _concrt_new std::exception_ptr(std::current_exception());
+        _OldStatus = _M_pException;
+        for(;;)
+        {
+            size_t _cancelStatus = ((size_t)_OldStatus & _S_cancelBitsMask);
+            void *_pExcWC = (void *)((size_t)_pExc | _cancelStatus);
+
+            void *_XchgStatus = _InterlockedCompareExchangePointer((void * volatile *) &_M_pException, _pExcWC, _OldStatus);
+            if (_XchgStatus == _OldStatus)
+                break;
+
+            _OldStatus = _XchgStatus;
+        }
+    }
+
+    /// <summary>
+    ///     Potentially rethrows the exception which was set with _RaisedException.  The caller has responsibility to ensure that _RaisedException
+    ///     was called prior to calling this and that _M_pException has progressed beyond the _S_nonNull state.
+    /// </summary>
+    void _TaskCollectionBase::_RethrowException()
+    {
+        //
+        // The cancellation exception is treated very specially within the runtime.  Do not arbitrarily rethrow from here.
+        //
+        std::exception_ptr *_pException = _Exception();
+        if (_pException != NULL && (size_t)_pException != _S_cancelException)
+        {
+            std::exception_ptr _curException = *_Exception();
+
+            delete _pException;
+            _M_pException = NULL;
+
+            if ( !__uncaught_exception())
+                std::rethrow_exception(_curException);
+        }
+    }
+
+    /// <summary>
+    ///     Marks the collection for cancellation and returns whether the collection was thus marked.
+    /// </summary>
+    bool _TaskCollectionBase::_MarkCancellation()
+    {
+        void *_OldStatus = _M_pException;
+        for(;;)
+        {
+            if ((size_t)_OldStatus & _S_cancelBitsMask) // already canceled
+                return false;
+
+            void *_XchgStatus = _InterlockedCompareExchangePointer((void * volatile *) &_M_pException,
+                                                                   (void *)((size_t)_OldStatus | _S_cancelStarted),
+                                                                   _OldStatus);
+            if (_XchgStatus == _OldStatus)
+                return true;
+
+            _OldStatus = _XchgStatus;
+        }
+    }
+
+    /// <summary>
+    ///     Finishes the cancellation state (changing from _S_cancelStarted to one of the other states).  Note that only the
+    ///     thread which successfully marked cancellation may call this.
+    /// </summary>
+    void _TaskCollectionBase::_FinishCancelState(size_t _NewCancelState)
+    {
+        ASSERT(_CancelState() == _S_cancelStarted);
+        ASSERT(_NewCancelState != _S_cancelNone && _NewCancelState != _S_cancelStarted);
+
+        void *_OldStatus = _M_pException;
+        for(;;)
+        {
+            void *_XchgStatus = _InterlockedCompareExchangePointer((void * volatile *) &_M_pException,
+                                                                   (void *)(((size_t)_OldStatus & ~_S_cancelBitsMask) | _NewCancelState),
+                                                                   _OldStatus);
+
+            if (_XchgStatus == _OldStatus)
+                break;
+
+            _OldStatus = _XchgStatus;
+        }
+    }
+
+    /// <summary>
+    ///     Called when a cancellation is raised on a chore on a given task collection.  This makes a determination of what to do with the exception
+    ///     and stores it for potential transport back to the thread performing a join on a chore collection.  Note that every other exception
+    ///     has precedence over a cancellation.
+    /// </summary>
+    void _TaskCollectionBase::_RaisedCancel()
+    {
+        void *_OldStatus = _M_pException;
+        for (;;)
+        {
+            std::exception_ptr *_pException = (std::exception_ptr *)((size_t)_OldStatus & ~_S_cancelBitsMask);
+            if (_pException != NULL)
+                return;
+
+            size_t _cancelStatus = ((size_t)_OldStatus & _S_cancelBitsMask);
+            void *pExcWC = (void *)(_S_cancelException | _cancelStatus);
+
+            void *_XchgStatus = _InterlockedCompareExchangePointer((void * volatile *) &_M_pException, pExcWC, _OldStatus);
+            if (_XchgStatus == _OldStatus)
+                break;
+
+            _OldStatus = _XchgStatus;
+        }
+    }
+
+    /// <summary>
+    ///     Called in order to determine whether this task collection will interrupt for a pending cancellation at or above it.
+    ///
+    bool _TaskCollectionBase::_WillInterruptForPendingCancel()
+    {
+        //
+        // We can only perform the interruption point if someone in the parentage chain is actually inlined.  The number of times where we get here
+        // without such should be minimal.
+        //
+        // Note that structured collections do not initialize _M_pParent until they are inlined.  In order to avoid excess initialization in the
+        // structured case, we key off that to determine the validity of the field.  Note that this check is perfectly okay for task collections
+        // as well.
+        //
+        _TaskCollectionBase *pParent = _SafeGetParent();
+        _CancellationTokenState *pTokenState = _GetTokenState();
+
+        while (pParent != NULL)
+        {
+            //
+            // If this token is non null- it could hide cancellation from a parent task collection.
+            //
+            if (pTokenState == NULL)
+            {
+                if ((pParent->_IsStructured() && (static_cast<_StructuredTaskCollection *>(pParent))->_IsMarkedForCancellation()) ||
+                    (!pParent->_IsStructured() && (static_cast<_TaskCollection *>(pParent))->_IsMarkedForAbnormalExit()))
+                    return true;
+            }
+            else
+            {
+                if (pTokenState == _CancellationTokenState::_None())
+                    return false;
+                else
+                    return pTokenState->_IsCanceled();
+            }
+            //
+            // Grab the parent token before switching to its parent.
+            //
+            pTokenState = pParent->_GetTokenState();
+            pParent = pParent->_SafeGetParent();
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Returns the cancellation token state associated with this task collection.
+    /// </summary>
+    _CancellationTokenState *_TaskCollectionBase::_GetTokenState(_CancellationTokenRegistration **_PRegistration)
+    {
+        _CancellationTokenState *pTokenState = _M_pTokenState;
+        _CancellationTokenRegistration *pRegistration = NULL;
+
+        if (reinterpret_cast<ULONG_PTR>(pTokenState) & TASKCOLLECTIONFLAG_POINTER_IS_REGISTRATION)
+        {
+            pRegistration = reinterpret_cast<_CancellationTokenRegistration *>(
+                reinterpret_cast<ULONG_PTR>(pTokenState) & ~TASKCOLLECTIONFLAG_POINTER_IS_REGISTRATION
+                );
+
+            if (pRegistration != NULL)
+            {
+                pTokenState = pRegistration->_GetToken();
+            }
+            else
+            {
+                pTokenState = _CancellationTokenState::_None();
+            }
+        }
+        if (_PRegistration != NULL)
+        {
+            *_PRegistration = pRegistration;
+        }
+        return pTokenState;
+    }
+
+} // namespace details
+} // namespace Concurrency

msvc/VC/Tools/MSVC/14.50.35717/crt/src/concrt/ThreadInternalContext.cpp

@@ -0,0 +1,23 @@
+// ==++==
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+// ThreadInternalContext.cpp
+//
+// Source file containing that implementation for a thread based internal execution context/stack.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#pragma once
+
+#include "concrtinternal.h"
+
+namespace Concurrency
+{
+namespace details
+{
+
+} // namespace details
+} // namespace Concurrency