|
|
//-----------------------------------------------------------------------------
//
//
// File: asyncq.cpp
//
// Description: Non-template asyncq implementations
//
// Author: Mike Swafford (MikeSwa)
//
// History:
// 2/23/99 - MikeSwa Created
//
// Copyright (C) 1999 Microsoft Corporation
//
//-----------------------------------------------------------------------------
#include "aqprecmp.h"
#include "asyncq.h"
#include "asyncq.inl"
DWORD CAsyncQueueBase::s_cAsyncQueueStaticInitRefCount = 0;DWORD CAsyncQueueBase::s_cMaxPerProcATQThreadAdjustment = 0;DWORD CAsyncQueueBase::s_cDefaultMaxAsyncThreads = 0;
// Some counters for debugging thread management
DWORD CAsyncQueueBase::s_cThreadCompletion_QueueEmpty = 0;DWORD CAsyncQueueBase::s_cThreadCompletion_CompletedScheduledItems = 0;DWORD CAsyncQueueBase::s_cThreadCompletion_UnacceptableThreadCount = 0;DWORD CAsyncQueueBase::s_cThreadCompletion_Timeout = 0;DWORD CAsyncQueueBase::s_cThreadCompletion_Failure = 0;DWORD CAsyncQueueBase::s_cThreadCompletion_Paused = 0;
// state transition table for the async queue state machine
STATE_TRANSITION CAsyncQueueBase::s_rgTransitionTable[] = { // start state normal:
{ ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_KICK, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_PAUSE, ASYNC_QUEUE_STATUS_PAUSED }, { ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_UNPAUSE, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_FREEZE, ASYNC_QUEUE_STATUS_FROZEN }, { ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_THAW, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_NORMAL, ASYNC_QUEUE_ACTION_SHUTDOWN, ASYNC_QUEUE_STATUS_SHUTDOWN }, // start state paused:
{ ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_KICK, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_PAUSE, ASYNC_QUEUE_STATUS_PAUSED }, { ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_UNPAUSE, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_FREEZE, ASYNC_QUEUE_STATUS_FROZENPAUSED }, { ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_THAW, ASYNC_QUEUE_STATUS_PAUSED }, { ASYNC_QUEUE_STATUS_PAUSED, ASYNC_QUEUE_ACTION_SHUTDOWN, ASYNC_QUEUE_STATUS_SHUTDOWN }, // start state frozen:
{ ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_KICK, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_PAUSE, ASYNC_QUEUE_STATUS_FROZENPAUSED }, { ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_UNPAUSE, ASYNC_QUEUE_STATUS_FROZEN }, { ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_FREEZE, ASYNC_QUEUE_STATUS_FROZEN }, { ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_THAW, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_FROZEN, ASYNC_QUEUE_ACTION_SHUTDOWN, ASYNC_QUEUE_STATUS_SHUTDOWN }, // start state frozenpaused:
{ ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_KICK, ASYNC_QUEUE_STATUS_NORMAL }, { ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_PAUSE, ASYNC_QUEUE_STATUS_FROZENPAUSED }, { ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_UNPAUSE, ASYNC_QUEUE_STATUS_FROZEN }, { ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_FREEZE, ASYNC_QUEUE_STATUS_FROZENPAUSED }, { ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_THAW, ASYNC_QUEUE_STATUS_PAUSED }, { ASYNC_QUEUE_STATUS_FROZENPAUSED, ASYNC_QUEUE_ACTION_SHUTDOWN, ASYNC_QUEUE_STATUS_SHUTDOWN }, // start state shutdown:
{ ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_KICK, ASYNC_QUEUE_STATUS_SHUTDOWN }, { ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_PAUSE, ASYNC_QUEUE_STATUS_SHUTDOWN }, { ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_UNPAUSE, ASYNC_QUEUE_STATUS_SHUTDOWN }, { ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_FREEZE, ASYNC_QUEUE_STATUS_SHUTDOWN }, { ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_THAW, ASYNC_QUEUE_STATUS_SHUTDOWN }, { ASYNC_QUEUE_STATUS_SHUTDOWN, ASYNC_QUEUE_ACTION_SHUTDOWN, ASYNC_QUEUE_STATUS_SHUTDOWN },}; //---[ CAsyncQueueBase::getTransitionTable ]------------
//
//
// Description:
// returns the state transition table and its size to
// CStateMachineBase whenever needed.
// Parameters:
// - ppTransitionTable pointer to the state transition table
// pdwNumTransitions pointer to the number of transitions in
// the table
// Returns:
// -
// History:
// 6/5/2000 - t-toddc Created
// 12/11/2000 - MikeSwa Merged for Hg checkin
//
//------------------------------------------------------------------
void CAsyncQueueBase::getTransitionTable(const STATE_TRANSITION** ppTransitionTable, DWORD* pdwNumTransitions){ TraceFunctEnter("CAsyncQueueStateMachine::getTransitionTable"); ASSERT(ppTransitionTable && "NULL transition table pointer"); ASSERT(pdwNumTransitions && "NULL num transitions pointer"); ASSERT(s_rgTransitionTable && "transition table uninitialized");
// bail on bad input or no good transition table
if (!ppTransitionTable || !pdwNumTransitions || !s_rgTransitionTable) goto Exit;
*ppTransitionTable = s_rgTransitionTable; *pdwNumTransitions = sizeof(CAsyncQueueBase::s_rgTransitionTable) / sizeof(STATE_TRANSITION);
Exit: TraceFunctLeave();}
//---[ CAsyncQueueBase::ThreadPoolInitialize ]---------------------------------
//
//
// Description:
// Performs static ATQ initialization. This call is ref-counted. If
// it succeeds, the caller should call ThreadPoolDeinitialze();
// Parameters:
// -
// Returns:
// -
// History:
// 3/30/2000 - MikeSwa Created
//
//-----------------------------------------------------------------------------
void CAsyncQueueBase::ThreadPoolInitialize(){ TraceFunctEnterEx((LPARAM) this, "CAsyncQueueBase::ThreadPoolInitialize"); DWORD cATQMaxAsyncThreads = 0; DWORD cATQMaxTotalAsyncThreads = 0; DWORD cOurMaxAsyncThreads = 0; SYSTEM_INFO sinf;
//
// On 0 -> 1 transition, adjust ATQ according to our config
//
if (!s_cAsyncQueueStaticInitRefCount) { //
// Get max threads per proc
//
cATQMaxAsyncThreads = (DWORD)AtqGetInfo(AtqMaxPoolThreads); _ASSERT(cATQMaxAsyncThreads && "AtqGetInfo says there are no threads!"); if (!cATQMaxAsyncThreads) cATQMaxAsyncThreads = 1;
cOurMaxAsyncThreads = cATQMaxAsyncThreads;
//
// Adjust value by our config value
//
cOurMaxAsyncThreads += g_cPerProcMaxThreadPoolModifier;
//
// Get # of procs (using GetSystemInfo)
//
GetSystemInfo(&sinf); cOurMaxAsyncThreads *= sinf.dwNumberOfProcessors;
//
// We will throttle our requests at g_cMaxATQPercent
// the max number of ATQ threads
//
cOurMaxAsyncThreads = (g_cMaxATQPercent*cOurMaxAsyncThreads)/100;
if (!cOurMaxAsyncThreads) cOurMaxAsyncThreads = 1;
//
// Set static so people later on can use this calculation
//
s_cDefaultMaxAsyncThreads = cOurMaxAsyncThreads;
//
// Now we need to adjust our threads
//
s_cMaxPerProcATQThreadAdjustment = g_cPerProcMaxThreadPoolModifier;
//
// Per proc thread limit
//
if (s_cMaxPerProcATQThreadAdjustment) { AtqSetInfo(AtqMaxPoolThreads, cATQMaxAsyncThreads + s_cMaxPerProcATQThreadAdjustment); DebugTrace((LPARAM) this, "Adjusting per proc ATQ thread limit by %d (orig %d)", s_cMaxPerProcATQThreadAdjustment, cATQMaxAsyncThreads); }
_ASSERT(!(0xFF000000 & cOurMaxAsyncThreads)); //sanity check number
}
s_cAsyncQueueStaticInitRefCount++;
TraceFunctLeave();}
//---[ CAsyncQueueBase::ThreadPoolDeinitialize ]-------------------------------
//
//
// Description:
// Will re-adjust ATQ data if we changed them during initialization
// Parameters:
// -
// Returns:
// -
// History:
// 3/30/2000 - MikeSwa Created
//
//-----------------------------------------------------------------------------
void CAsyncQueueBase::ThreadPoolDeinitialize(){ TraceFunctEnterEx((LPARAM) this, "CAsyncQueueBase::ThreadPoolDeinitialize"); DWORD cATQMaxAsyncThreads = 0; DWORD cATQMaxTotalAsyncThreads = 0;
_ASSERT(s_cAsyncQueueStaticInitRefCount != 0); s_cAsyncQueueStaticInitRefCount--;
//
// If this is the last queue, adjust our configuration so back to
// the way we found it.
//
if (!s_cAsyncQueueStaticInitRefCount) { cATQMaxAsyncThreads = (DWORD)AtqGetInfo(AtqMaxPoolThreads); cATQMaxTotalAsyncThreads = (DWORD) AtqGetInfo(AtqMaxThreadLimit);
//
// Reset per-proc threads if it makes sense
//
if (s_cMaxPerProcATQThreadAdjustment && (cATQMaxAsyncThreads > s_cMaxPerProcATQThreadAdjustment)) { AtqSetInfo(AtqMaxPoolThreads, cATQMaxAsyncThreads - s_cMaxPerProcATQThreadAdjustment);
DebugTrace((LPARAM) this, "Resetting ATQ Max per proc threads to %d", cATQMaxAsyncThreads - s_cMaxPerProcATQThreadAdjustment);
s_cMaxPerProcATQThreadAdjustment = 0; }
}
// Verify that m_cThreadsNeeded has reached zero
_ASSERT(!m_cThreadsNeeded);
TraceFunctLeave();}
|
