archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/multimedia/directx/dplay/dplay8/threadpool/work.cpp

2692 lines
80 KiB
Raw Blame History

/******************************************************************************
*
* Copyright (C) 2001-2002 Microsoft Corporation. All Rights Reserved.
*
* File: work.cpp
*
* Content: DirectPlay Thread Pool work processing functions.
*
* History:
* Date By Reason
* ======== ======== =========
* 10/31/01 VanceO Created.
*
******************************************************************************/
#include "dpnthreadpooli.h"
//=============================================================================
// Defines
//=============================================================================
#define MAX_SIMULTANEOUS_THREAD_START (MAXIMUM_WAIT_OBJECTS - 1) // WaitForMultipleObjects can only handle 64 items at a time, we need one slot for the start event
#undef DPF_MODNAME
#define DPF_MODNAME "InitializeWorkQueue"
//=============================================================================
// InitializeWorkQueue
//-----------------------------------------------------------------------------
//
// Description: Initializes the specified work queue.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object to
// initialize.
// DWORD dwCPUNum - CPU number this queue is to
// represent.
// PFNDPNMESSAGEHANDLER pfnMsgHandler - User's message handler callback, or
// NULL if none.
// PVOID pvMsgHandlerContext - Context for user's message handler.
// DWORD dwWorkerThreadTlsIndex - TLS index to use for storing worker
// thread data.
//
// Returns: HRESULT
// DPN_OK - Successfully initialized the work queue object.
// DPNERR_OUTOFMEMORY - Failed to allocate memory while initializing.
//=============================================================================
#ifdef DPNBUILD_ONLYONETHREAD
#ifdef DPNBUILD_ONLYONEPROCESSOR
HRESULT InitializeWorkQueue(DPTPWORKQUEUE * const pWorkQueue)
#else // ! DPNBUILD_ONLYONEPROCESSOR
HRESULT InitializeWorkQueue(DPTPWORKQUEUE * const pWorkQueue,
const DWORD dwCPUNum)
#endif // ! DPNBUILD_ONLYONEPROCESSOR
#else // ! DPNBUILD_ONLYONETHREAD
HRESULT InitializeWorkQueue(DPTPWORKQUEUE * const pWorkQueue,
#ifndef DPNBUILD_ONLYONEPROCESSOR
const DWORD dwCPUNum,
#endif // ! DPNBUILD_ONLYONEPROCESSOR
const PFNDPNMESSAGEHANDLER pfnMsgHandler,
PVOID const pvMsgHandlerContext,
const DWORD dwWorkerThreadTlsIndex)
#endif // ! DPNBUILD_ONLYONETHREAD
{
HRESULT hr;
BOOL fInittedWorkItemPool = FALSE;
#if ((! defined(WINCE)) || (defined(DBG)))
BOOL fInittedListLock = FALSE;
#endif // ! WINCE or DBG
BOOL fInittedTimerInfo = FALSE;
#ifndef WINCE
BOOL fInittedIoInfo = FALSE;
#endif // ! WINCE
#ifdef DBG
DWORD dwError;
#endif // DBG
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pWorkQueue);
pWorkQueue->Sig[0] = 'W';
pWorkQueue->Sig[1] = 'R';
pWorkQueue->Sig[2] = 'K';
pWorkQueue->Sig[3] = 'Q';
pWorkQueue->pWorkItemPool = (CFixedPool*) DNMalloc(sizeof(CFixedPool));
if (pWorkQueue->pWorkItemPool == NULL)
{
DPFX(DPFPREP, 0, "Couldn't allocate new work item pool!");
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
if (! pWorkQueue->pWorkItemPool->Initialize(sizeof(CWorkItem),
CWorkItem::FPM_Alloc,
CWorkItem::FPM_Get,
CWorkItem::FPM_Release,
//CWorkItem::FPM_Dealloc))
NULL))
{
DPFX(DPFPREP, 0, "Couldn't initialize work item pool!");
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
fInittedWorkItemPool = TRUE;
#if ((! defined(WINCE)) || (defined(DBG)))
if (! DNInitializeCriticalSection(&pWorkQueue->csListLock))
{
DPFX(DPFPREP, 0, "Couldn't initialize list lock!");
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
DebugSetCriticalSectionRecursionCount(&pWorkQueue->csListLock, 0);
fInittedListLock = TRUE;
#endif // ! WINCE or DBG
#ifndef DPNBUILD_USEIOCOMPLETIONPORTS
DNInitializeSListHead(&pWorkQueue->SlistFreeQueueNodes);
//
// Add an initial node entry as required by NB Queue implementation.
//
DNInterlockedPushEntrySList(&pWorkQueue->SlistFreeQueueNodes,
(DNSLIST_ENTRY*) (&pWorkQueue->NBQueueBlockInitial));
//
// Initialize the actual non-blocking queue.
//
pWorkQueue->pvNBQueueWorkItems = DNInitializeNBQueueHead(&pWorkQueue->SlistFreeQueueNodes);
if (pWorkQueue->pvNBQueueWorkItems == NULL)
{
DPFX(DPFPREP, 0, "Couldn't initialize non-blocking queue!");
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#ifndef DPNBUILD_ONLYONETHREAD
pWorkQueue->fTimerThreadNeeded = TRUE;
pWorkQueue->dwNumThreadsExpected = 0;
pWorkQueue->dwNumBusyThreads = 0;
pWorkQueue->dwNumRunningThreads = 0;
#endif // ! DPNBUILD_ONLYONETHREAD
#ifndef DPNBUILD_ONLYONEPROCESSOR
pWorkQueue->dwCPUNum = dwCPUNum;
#endif // ! DPNBUILD_ONLYONEPROCESSOR
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
//
// Create an I/O completion port.
//
HANDLE hIoCompletionPort;
hIoCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,
NULL,
0,
0);
if (hIoCompletionPort == NULL)
{
#ifdef DBG
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't create I/O completion port (err = %u)!", dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
pWorkQueue->hIoCompletionPort = MAKE_DNHANDLE(hIoCompletionPort);
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
//
// Create an event used to wake up idle worker threads.
//
pWorkQueue->hAlertEvent = DNCreateEvent(NULL, FALSE, FALSE, NULL);
if (pWorkQueue->hAlertEvent == NULL)
{
#ifdef DBG
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't create alert event (err = %u)!", dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#ifndef DPNBUILD_ONLYONETHREAD
pWorkQueue->hExpectedThreadsEvent = NULL;
pWorkQueue->pfnMsgHandler = pfnMsgHandler;
pWorkQueue->pvMsgHandlerContext = pvMsgHandlerContext;
pWorkQueue->dwWorkerThreadTlsIndex = dwWorkerThreadTlsIndex;
#endif // ! DPNBUILD_ONLYONETHREAD
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Initialize our debugging/tuning statistics.
//
pWorkQueue->dwTotalNumWorkItems = 0;
#ifndef WINCE
pWorkQueue->dwTotalTimeSpentUnsignalled = 0;
pWorkQueue->dwTotalTimeSpentInWorkCallbacks = 0;
#endif // ! WINCE
#ifndef DPNBUILD_ONLYONETHREAD
pWorkQueue->dwTotalNumTimerThreadAbdications = 0;
#endif // ! DPNBUILD_ONLYONETHREAD
pWorkQueue->dwTotalNumWakesWithoutWork = 0;
pWorkQueue->dwTotalNumContinuousWork = 0;
pWorkQueue->dwTotalNumDoWorks = 0;
pWorkQueue->dwTotalNumDoWorksTimeLimit = 0;
pWorkQueue->dwTotalNumSimultaneousQueues = 0;
memset(pWorkQueue->aCallbackStats, 0, sizeof(pWorkQueue->aCallbackStats));
#endif // DPNBUILD_THREADPOOLSTATISTICS
#ifdef DBG
#ifndef DPNBUILD_ONLYONETHREAD
//
// Initialize the structures helpful for debugging.
//
pWorkQueue->blThreadList.Initialize();
#endif // ! DPNBUILD_ONLYONETHREAD
#endif // DBG
//
// Initialize the timer aspects of the work queue
//
hr = InitializeWorkQueueTimerInfo(pWorkQueue);
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "Couldn't initialize timer info for work queue!");
goto Failure;
}
fInittedTimerInfo = TRUE;
#ifndef WINCE
//
// Initialize the I/O aspects of the work queue
//
hr = InitializeWorkQueueIoInfo(pWorkQueue);
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "Couldn't initialize I/O info for work queue!");
goto Failure;
}
fInittedIoInfo = TRUE;
#endif // ! WINCE
Exit:
DPFX(DPFPREP, 6, "Returning: [0x%lx]", hr);
return hr;
Failure:
#ifndef WINCE
if (fInittedIoInfo)
{
DeinitializeWorkQueueIoInfo(pWorkQueue);
fInittedIoInfo = FALSE;
}
#endif // ! WINCE
if (fInittedTimerInfo)
{
DeinitializeWorkQueueTimerInfo(pWorkQueue);
fInittedTimerInfo = FALSE;
}
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
if (pWorkQueue->hIoCompletionPort != NULL)
{
DNCloseHandle(pWorkQueue->hIoCompletionPort);
pWorkQueue->hIoCompletionPort = NULL;
}
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
if (pWorkQueue->hAlertEvent != NULL)
{
DNCloseHandle(pWorkQueue->hAlertEvent);
pWorkQueue->hAlertEvent = NULL;
}
if (pWorkQueue->pvNBQueueWorkItems != NULL)
{
DNDeinitializeNBQueueHead(pWorkQueue->pvNBQueueWorkItems);
pWorkQueue->pvNBQueueWorkItems = NULL;
}
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#if ((! defined(WINCE)) || (defined(DBG)))
if (fInittedListLock)
{
DNDeleteCriticalSection(&pWorkQueue->csListLock);
fInittedListLock = FALSE;
}
#endif // ! WINCE or DBG
if (pWorkQueue->pWorkItemPool != NULL)
{
if (fInittedWorkItemPool)
{
pWorkQueue->pWorkItemPool->DeInitialize();
fInittedWorkItemPool = FALSE;
}
DNFree(pWorkQueue->pWorkItemPool);
pWorkQueue->pWorkItemPool = NULL;
}
goto Exit;
} // InitializeWorkQueue
#undef DPF_MODNAME
#define DPF_MODNAME "DeinitializeWorkQueue"
//=============================================================================
// DeinitializeWorkQueue
//-----------------------------------------------------------------------------
//
// Description: Cleans up the work queue.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object to clean up.
//
// Returns: Nothing.
//=============================================================================
void DeinitializeWorkQueue(DPTPWORKQUEUE * const pWorkQueue)
{
#ifndef DPNBUILD_ONLYONETHREAD
HRESULT hr;
#endif // ! DPNBUILD_ONLYONETHREAD
BOOL fResult;
#ifdef DBG
DWORD dwMaxRecursionCount = 0;
#ifdef WINNT
HANDLE hThread;
FILETIME ftIgnoredCreation;
FILETIME ftIgnoredExit;
ULONGLONG ullKernel;
ULONGLONG ullUser;
#endif // WINNT
#endif // DBG
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pWorkQueue);
#ifndef DPNBUILD_ONLYONETHREAD
#ifdef DBG
//
// Assert that there are truly threads running if there's supposed to be,
// and that we're not being called on one of those threads.
//
DNEnterCriticalSection(&pWorkQueue->csListLock);
if (pWorkQueue->dwNumRunningThreads > 0)
{
CBilink * pBilink;
DPTPWORKERTHREAD * pWorkerThread;
DNASSERT(! pWorkQueue->blThreadList.IsEmpty());
pBilink = pWorkQueue->blThreadList.GetNext();
while (pBilink != &pWorkQueue->blThreadList)
{
pWorkerThread = CONTAINING_OBJECT(pBilink, DPTPWORKERTHREAD, blList);
#ifdef WINNT
hThread = OpenThread(THREAD_QUERY_INFORMATION, FALSE, pWorkerThread->dwThreadID);
if (hThread != NULL)
{
if (GetThreadTimes(hThread, &ftIgnoredCreation, &ftIgnoredExit, (LPFILETIME) (&ullKernel), (LPFILETIME) (&ullUser)))
{
DPFX(DPFPREP, 6, "Found worker thread ID %u/0x%x, max recursion = %u, user time = %u, kernel time = %u.",
pWorkerThread->dwThreadID, pWorkerThread->dwThreadID,
pWorkerThread->dwMaxRecursionCount,
(ULONG) (ullUser / ((ULONGLONG) 10000)),
(ULONG) (ullKernel / ((ULONGLONG) 10000)));
}
else
{
DPFX(DPFPREP, 6, "Found worker thread ID %u/0x%x, max recursion = %u (get thread times failed).",
pWorkerThread->dwThreadID, pWorkerThread->dwThreadID,
pWorkerThread->dwMaxRecursionCount);
}
CloseHandle(hThread);
hThread = NULL;
}
else
#endif // WINNT
{
DPFX(DPFPREP, 6, "Found worker thread ID %u/0x%x, max recursion = %u.",
pWorkerThread->dwThreadID, pWorkerThread->dwThreadID,
pWorkerThread->dwMaxRecursionCount);
}
DNASSERT(pWorkerThread->dwThreadID != GetCurrentThreadId());
if (pWorkerThread->dwMaxRecursionCount > dwMaxRecursionCount)
{
dwMaxRecursionCount = pWorkerThread->dwMaxRecursionCount;
}
pBilink = pBilink->GetNext();
}
}
else
{
DNASSERT(pWorkQueue->blThreadList.IsEmpty());
}
DNLeaveCriticalSection(&pWorkQueue->csListLock);
#endif // DBG
//
// Stop all threads, if there were any.
//
if (pWorkQueue->dwNumRunningThreads > 0)
{
hr = StopThreads(pWorkQueue, pWorkQueue->dwNumRunningThreads);
DNASSERT(hr == DPN_OK);
}
else
{
//
// Make sure the count didn't go negative.
//
DNASSERT(pWorkQueue->dwNumRunningThreads == 0);
}
//
// All threads should be gone by now. Technically, that isn't true because
// they still have some minor cleanup code to run after decrementing
// lNumRunningThreads. But for our purposes, the threads are gone.
// We also know that they pull themselves out of blThreadList prior to
// alerting us that they've left, so the list should be empty by now.
//
#ifdef DBG
DNASSERT(pWorkQueue->blThreadList.IsEmpty());
#endif // DBG
#endif // ! DPNBUILD_ONLYONETHREAD
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Print our debugging/tuning statistics.
//
#ifdef DPNBUILD_ONLYONEPROCESSOR
DPFX(DPFPREP, 7, "Work queue 0x%p work stats:", pWorkQueue);
#else // ! DPNBUILD_ONLYONEPROCESSOR
DPFX(DPFPREP, 7, "Work queue 0x%p (CPU %u) work stats:", pWorkQueue, pWorkQueue->dwCPUNum);
#endif // ! DPNBUILD_ONLYONEPROCESSOR
DPFX(DPFPREP, 7, " TotalNumWorkItems = %u", pWorkQueue->dwTotalNumWorkItems);
#ifndef WINCE
DPFX(DPFPREP, 7, " TotalTimeSpentUnsignalled = %u", pWorkQueue->dwTotalTimeSpentUnsignalled);
DPFX(DPFPREP, 7, " TotalTimeSpentInWorkCallbacks = %u", pWorkQueue->dwTotalTimeSpentInWorkCallbacks);
#endif // ! WINCE
#ifndef DPNBUILD_ONLYONETHREAD
DPFX(DPFPREP, 7, " TotalNumTimerThreadAbdications = %u", pWorkQueue->dwTotalNumTimerThreadAbdications);
#endif // ! DPNBUILD_ONLYONETHREAD
DPFX(DPFPREP, 7, " TotalNumWakesWithoutWork = %u", pWorkQueue->dwTotalNumWakesWithoutWork);
DPFX(DPFPREP, 7, " TotalNumContinuousWork = %u", pWorkQueue->dwTotalNumContinuousWork);
DPFX(DPFPREP, 7, " TotalNumDoWorks = %u", pWorkQueue->dwTotalNumDoWorks);
DPFX(DPFPREP, 7, " TotalNumDoWorksTimeLimit = %u", pWorkQueue->dwTotalNumDoWorksTimeLimit);
DPFX(DPFPREP, 7, " TotalNumSimultaneousQueues = %u", pWorkQueue->dwTotalNumSimultaneousQueues);
DPFX(DPFPREP, 7, " MaxRecursionCount = %u", dwMaxRecursionCount);
#endif // DPNBUILD_THREADPOOLSTATISTICS
#ifndef WINCE
DeinitializeWorkQueueIoInfo(pWorkQueue);
#endif // ! WINCE
DeinitializeWorkQueueTimerInfo(pWorkQueue);
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
fResult = DNCloseHandle(pWorkQueue->hIoCompletionPort);
DNASSERT(fResult);
pWorkQueue->hIoCompletionPort = NULL;
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
fResult = DNCloseHandle(pWorkQueue->hAlertEvent);
DNASSERT(fResult);
pWorkQueue->hAlertEvent = NULL;
DNASSERT(DNIsNBQueueEmpty(pWorkQueue->pvNBQueueWorkItems));
DNDeinitializeNBQueueHead(pWorkQueue->pvNBQueueWorkItems);
pWorkQueue->pvNBQueueWorkItems = NULL;
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#if ((! defined(WINCE)) || (defined(DBG)))
DNDeleteCriticalSection(&pWorkQueue->csListLock);
#endif // ! WINCE or DBG
//
// All of the NB queue nodes should be back in the pool, but there's no way
// to tell if we have the correct amount.
//
DNASSERT(pWorkQueue->pWorkItemPool != NULL);
pWorkQueue->pWorkItemPool->DeInitialize();
DNFree(pWorkQueue->pWorkItemPool);
pWorkQueue->pWorkItemPool = NULL;
DPFX(DPFPREP, 6, "Leave");
} // DeinitializeWorkQueue
#undef DPF_MODNAME
#define DPF_MODNAME "QueueWorkItem"
//=============================================================================
// QueueWorkItem
//-----------------------------------------------------------------------------
//
// Description: Queues a new work item for processing.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object to use.
// PFNDPTNWORKCALLBACK pfnWorkCallback - Callback to execute as soon as
// possible.
// PVOID pvCallbackContext - User specified context to pass to
// callback.
//
// Returns: BOOL
// TRUE - Successfully queued the item.
// FALSE - Failed to allocate memory for queueing the item.
//=============================================================================
BOOL QueueWorkItem(DPTPWORKQUEUE * const pWorkQueue,
const PFNDPTNWORKCALLBACK pfnWorkCallback,
PVOID const pvCallbackContext)
{
CWorkItem * pWorkItem;
BOOL fResult;
pWorkItem = (CWorkItem*) pWorkQueue->pWorkItemPool->Get(pWorkQueue);
if (pWorkItem == NULL)
{
DPFX(DPFPREP, 0, "Couldn't get new work item from pool!");
return FALSE;
}
DPFX(DPFPREP, 5, "Creating and queuing work item 0x%p (fn = 0x%p, context = 0x%p, queue = 0x%p).",
pWorkItem, pfnWorkCallback, pvCallbackContext, pWorkQueue);
pWorkItem->m_pfnWorkCallback = pfnWorkCallback;
pWorkItem->m_pvCallbackContext = pvCallbackContext;
#ifdef DPNBUILD_THREADPOOLSTATISTICS
pWorkItem->m_fCancelledOrCompleting = TRUE;
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumWorkItems));
ThreadpoolStatsCreate(pWorkItem);
ThreadpoolStatsQueue(pWorkItem);
#endif // DPNBUILD_THREADPOOLSTATISTICS
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
fResult = PostQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
0,
0,
&pWorkItem->m_Overlapped);
if (! fResult)
{
#ifdef DBG
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't post queued completion status to port 0x%p (err = %u)!",
pWorkQueue->hIoCompletionPort, dwError);
#endif // DBG
//
// Careful, the item has been queued but it's possibly nobody knows...
//
}
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
DNInsertTailNBQueue(pWorkQueue->pvNBQueueWorkItems,
(ULONG64) pWorkItem);
//
// Alert the threads that there's a new item to process.
//
fResult = DNSetEvent(pWorkQueue->hAlertEvent);
if (! fResult)
{
#ifdef DBG
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't set alert event 0x%p (err = %u)!",
pWorkQueue->hAlertEvent, dwError);
#endif // DBG
//
// Careful, the item has been queued but it's possibly nobody knows...
//
}
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
return TRUE;
} // QueueWorkItem
#ifndef DPNBUILD_ONLYONETHREAD
#undef DPF_MODNAME
#define DPF_MODNAME "StartThreads"
//=============================================================================
// StartThreads
//-----------------------------------------------------------------------------
//
// Description: Increases the number of threads for the work queue.
//
// It is assumed that only one thread will call this function
// at a time, and no threads are currently being stopped.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object.
// DWORD dwNumThreads - Number of threads to start.
//
// Returns: HRESULT
// DPN_OK - Increasing the number of threads was successful.
// DPNERR_OUTOFMEMORY - Not enough memory to alter the number of threads.
//=============================================================================
HRESULT StartThreads(DPTPWORKQUEUE * const pWorkQueue,
const DWORD dwNumThreads)
{
HRESULT hr = DPN_OK;
DNHANDLE ahWaitObjects[MAX_SIMULTANEOUS_THREAD_START + 1];
DWORD adwThreadID[MAX_SIMULTANEOUS_THREAD_START];
DWORD dwNumThreadsExpected;
DWORD dwTotalThreadsRemaining;
DWORD dwTemp;
DWORD dwResult;
#ifdef DBG
DWORD dwError;
#endif // DBG
DNASSERT(dwNumThreads > 0);
//
// Fill the entire array with NULL.
//
memset(ahWaitObjects, 0, sizeof(ahWaitObjects));
//
// Initialize the remaining count.
//
dwTotalThreadsRemaining = dwNumThreads;
//
// Create an event that will be set when an entire batch of threads has
// successfully started.
//
ahWaitObjects[0] = DNCreateEvent(NULL, FALSE, FALSE, NULL);
if (ahWaitObjects[0] == NULL)
{
#ifdef DBG
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't create event (err = %u)!", dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
DNASSERT(pWorkQueue->hExpectedThreadsEvent == NULL);
pWorkQueue->hExpectedThreadsEvent = ahWaitObjects[0];
//
// Keep adding batches of threads until we've started the requested amount.
//
while (dwTotalThreadsRemaining > 0)
{
//
// Set the counter of how many threads we're starting in this batch.
// WaitForSingleObjects can only handle a fixed amount of handles
// at a time, so if we can't fit any more, we'll have to pick them
// up again in the next loop.
//
//
dwNumThreadsExpected = dwTotalThreadsRemaining;
if (dwNumThreadsExpected > MAX_SIMULTANEOUS_THREAD_START)
{
dwNumThreadsExpected = MAX_SIMULTANEOUS_THREAD_START;
}
DNASSERT(pWorkQueue->dwNumThreadsExpected == 0);
pWorkQueue->dwNumThreadsExpected = dwNumThreadsExpected;
for(dwTemp = 1; dwTemp <= dwNumThreadsExpected; dwTemp++)
{
ahWaitObjects[dwTemp] = DNCreateThread(NULL,
0,
DPTPWorkerThreadProc,
pWorkQueue,
0,
&adwThreadID[dwTemp - 1]);
if (ahWaitObjects[dwTemp] == NULL)
{
#ifdef DBG
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't create thread (err = %u)!", dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
dwTotalThreadsRemaining--;
}
//
// Wait for either the successful start event or one of the threads to
// die prematurely.
//
DPFX(DPFPREP, 4, "Waiting for %u threads for queue 0x%p to start.",
dwNumThreadsExpected, pWorkQueue);
dwResult = DNWaitForMultipleObjects((dwNumThreadsExpected + 1),
ahWaitObjects,
FALSE,
INFINITE);
if (dwResult != WAIT_OBJECT_0)
{
if ((dwResult > WAIT_OBJECT_0) &&
(dwResult <= (WAIT_OBJECT_0 + (MAX_SIMULTANEOUS_THREAD_START - 1))))
{
#ifdef DBG
dwResult -= WAIT_OBJECT_0;
dwError = 0;
GetExitCodeThread(ahWaitObjects[dwResult + 1], &dwError);
DPFX(DPFPREP, 0, "Thread index %u (ID %u/0x%x shut down before starting successfully (err = %u)!",
dwResult, adwThreadID[dwResult], adwThreadID[dwResult], dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
#ifdef DBG
dwError = GetLastError();
DPFX(DPFPREP, 0, "Waiting for threads to start failed (err = %u)!",
dwError);
#endif // DBG
hr = DPNERR_GENERIC;
goto Failure;
}
//
// All the threads we were expecting to start, did.
//
DPFX(DPFPREP, 4, "Successfully started %u threads for queue 0x%p.",
dwNumThreadsExpected, pWorkQueue);
//
// Close the handles for those threads since we will never use them
// again.
//
while (dwNumThreadsExpected > 0)
{
DNCloseHandle(ahWaitObjects[dwNumThreadsExpected]);
ahWaitObjects[dwNumThreadsExpected] = NULL;
dwNumThreadsExpected--;
}
} // end while (still more threads to add)
DNCloseHandle(ahWaitObjects[0]);
ahWaitObjects[0] = NULL;
Exit:
pWorkQueue->hExpectedThreadsEvent = NULL;
return hr;
Failure:
for(dwTemp = 0; dwTemp <= MAX_SIMULTANEOUS_THREAD_START; dwTemp++)
{
if (ahWaitObjects[dwTemp] != NULL)
{
DNCloseHandle(ahWaitObjects[dwTemp]);
ahWaitObjects[dwTemp] = NULL;
}
}
//
// Stop all threads that we successfully launched so that we end up back in
// the same state as when we started. Ignore error because we're already
// failing.
//
dwNumThreadsExpected = dwNumThreads - dwTotalThreadsRemaining;
if (dwNumThreadsExpected > 0)
{
pWorkQueue->hExpectedThreadsEvent = NULL;
StopThreads(pWorkQueue, dwNumThreadsExpected);
}
goto Exit;
} // StartThreads
#undef DPF_MODNAME
#define DPF_MODNAME "StopThreads"
//=============================================================================
// StopThreads
//-----------------------------------------------------------------------------
//
// Description: Decreases the number of threads for the work queue.
//
// It is assumed that only one thread will call this function
// at a time, and no threads are currently being started.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object.
// DWORD dwNumThreads - Number of threads to stop.
//
// Returns: HRESULT
// DPN_OK - Decreasing the number of threads was successful.
// DPNERR_OUTOFMEMORY - Not enough memory to alter the number of threads.
//=============================================================================
HRESULT StopThreads(DPTPWORKQUEUE * const pWorkQueue,
const DWORD dwNumThreads)
{
HRESULT hr;
DWORD dwTemp;
DWORD dwResult;
DNASSERT(dwNumThreads > 0);
//
// Create an event that will be set when the desired number of threads has
// started shutting down.
//
DNASSERT(pWorkQueue->hExpectedThreadsEvent == NULL);
pWorkQueue->hExpectedThreadsEvent = DNCreateEvent(NULL, FALSE, FALSE, NULL);
if (pWorkQueue->hExpectedThreadsEvent == NULL)
{
#ifdef DBG
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Couldn't create event (err = %u)!", dwError);
#endif // DBG
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
DNASSERT(pWorkQueue->dwNumThreadsExpected == 0);
pWorkQueue->dwNumThreadsExpected = dwNumThreads;
for(dwTemp = 0; dwTemp < dwNumThreads; dwTemp++)
{
//
// Queueing something with a NULL callback signifies "exit thread".
//
if (! QueueWorkItem(pWorkQueue, NULL, NULL))
{
DPFX(DPFPREP, 0, "Couldn't queue exit thread work item!");
hr = DPNERR_OUTOFMEMORY;
goto Failure;
}
} // end while (still more threads to remove)
//
// Wait for the last thread out to set the event.
//
DPFX(DPFPREP, 4, "Waiting for %u threads from queue 0x%p to stop.",
dwNumThreads, pWorkQueue);
dwResult = DNWaitForSingleObject(pWorkQueue->hExpectedThreadsEvent, INFINITE);
DNASSERT(dwResult == WAIT_OBJECT_0);
//
// When the wait completes successfully, it means that the threads are on
// their way out. It does *not* mean the threads have stopped completely.
// We have to assume that the threads will have time to fully quit before
// anything major happens, such as unloading this module.
//
hr = DPN_OK;
Exit:
if (pWorkQueue->hExpectedThreadsEvent != NULL)
{
DNCloseHandle(pWorkQueue->hExpectedThreadsEvent);
pWorkQueue->hExpectedThreadsEvent = NULL;
}
return hr;
Failure:
goto Exit;
} // StopThreads
#endif // ! DPNBUILD_ONLYONETHREAD
#undef DPF_MODNAME
#define DPF_MODNAME "DoWork"
//=============================================================================
// DoWork
//-----------------------------------------------------------------------------
//
// Description: Performs any work that is currently scheduled for the given
// queue. If dwMaxDoWorkTime is not INFINITE, work is started up
// until that time. At least one work item (if there is one) will
// always be executed.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object to use.
// DWORD dwMaxDoWorkTime - Maximum time at which a new job can be
// started, or INFINITE if all jobs should be
// processed before returning.
//
// Returns: Nothing.
//=============================================================================
void DoWork(DPTPWORKQUEUE * const pWorkQueue,
const DWORD dwMaxDoWorkTime)
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
{
BOOL fNeedToServiceTimers;
CWorkItem * pWorkItem;
BOOL fResult;
DWORD dwBytesTransferred;
DWORD dwCompletionKey;
OVERLAPPED * pOverlapped;
UINT uiOriginalUniqueID;
DPFX(DPFPREP, 8, "Parameters: (0x%p, %i)", pWorkQueue, dwMaxDoWorkTime);
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumDoWorks));
#endif // DPNBUILD_THREADPOOLSTATISTICS
//
// See if no one is processing timers.
//
fNeedToServiceTimers = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
FALSE);
//
// If need be, handle any expired or cancelled timer entries.
//
if (fNeedToServiceTimers)
{
ProcessTimers(pWorkQueue);
DPFX(DPFPREP, 8, "Abdicating timer thread responsibilities because of DoWork.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
pWorkQueue->dwTotalNumTimerThreadAbdications++;
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNASSERT(! pWorkQueue->fTimerThreadNeeded);
#pragma TODO(vanceo, "Does this truly need to be interlocked?")
fNeedToServiceTimers = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) TRUE);
DNASSERT(! fNeedToServiceTimers); // there had better not be more than one timer thread
}
//
// Keep looping until we run out of items to do. Note that this thread
// does not try to count itself as busy. Either we are in DoWork mode
// proper where the busy thread concept has no meaning, or we are a worker
// thread processing a job that called WaitWhileWorking where
// pWorkQueue->lNumBusyThreads would already have been incremented.
//
while ((GetQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
&dwBytesTransferred,
&dwCompletionKey,
&pOverlapped,
0)) ||
(pOverlapped != NULL))
{
pWorkItem = CONTAINING_OBJECT(pOverlapped, CWorkItem, m_Overlapped);
DNASSERT(pWorkItem->IsValid());
//
// Call the user's function or note that we may need to stop running.
//
if (pWorkItem->m_pfnWorkCallback != NULL)
{
//
// Save the uniqueness ID to determine if this item was a timer
// that got rescheduled.
//
uiOriginalUniqueID = pWorkItem->m_uiUniqueID;
DPFX(DPFPREP, 8, "Begin executing work item 0x%p (fn = 0x%p, context = 0x%p, unique = %u, queue = 0x%p).",
pWorkItem, pWorkItem->m_pfnWorkCallback,
pWorkItem->m_pvCallbackContext, uiOriginalUniqueID,
pWorkQueue);
ThreadpoolStatsBeginExecuting(pWorkItem);
pWorkItem->m_pfnWorkCallback(pWorkItem->m_pvCallbackContext,
pWorkItem,
uiOriginalUniqueID);
//
// Return the item to the pool unless it got rescheduled. This
// assumes that the actual pWorkItem memory remains valid even
// though it may have been rescheduled and then completed/cancelled
// by the time we perform this test. See CancelTimer.
//
if (uiOriginalUniqueID == pWorkItem->m_uiUniqueID)
{
ThreadpoolStatsEndExecuting(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, returning to pool.", pWorkItem);
pWorkQueue->pWorkItemPool->Release(pWorkItem);
}
else
{
ThreadpoolStatsEndExecutingRescheduled(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, it was rescheduled.", pWorkItem);
}
}
else
{
DPFX(DPFPREP, 3, "Requeuing exit thread work item 0x%p for other threads.",
pWorkItem);
fResult = PostQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
0,
0,
&pWorkItem->m_Overlapped);
DNASSERT(fResult);
#pragma BUGBUG(vanceo, "May not have processed everything we want")
break;
}
//
// Make sure we haven't exceeded our time limit (if we have one).
//
if ((dwMaxDoWorkTime != INFINITE) &&
((int) (dwMaxDoWorkTime - GETTIMESTAMP()) < 0))
{
DPFX(DPFPREP, 5, "Exceeded time limit, not processing any more work.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumDoWorksTimeLimit));
#endif // DPNBUILD_THREADPOOLSTATISTICS
break;
}
}
DPFX(DPFPREP, 8, "Leave");
} // DoWork
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
{
DNSLIST_ENTRY * pSlistEntryHead = NULL;
USHORT usCount = 0;
DNSLIST_ENTRY * pSlistEntryTail;
CWorkItem * pWorkItem;
UINT uiOriginalUniqueID;
#ifndef DPNBUILD_ONLYONETHREAD
BOOL fNeedToServiceTimers;
#endif // ! DPNBUILD_ONLYONETHREAD
DPFX(DPFPREP, 8, "Parameters: (0x%p, %i)", pWorkQueue, dwMaxDoWorkTime);
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumDoWorks));
#endif // DPNBUILD_THREADPOOLSTATISTICS
#ifndef WINCE
//
// Handle any I/O completions.
//
ProcessIo(pWorkQueue, &pSlistEntryHead, &pSlistEntryTail, &usCount);
#endif // ! WINCE
#ifndef DPNBUILD_ONLYONETHREAD
//
// See if no one is processing timers.
//
fNeedToServiceTimers = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
FALSE);
//
// If need be, handle any expired or cancelled timer entries.
//
if (fNeedToServiceTimers)
#endif // ! DPNBUILD_ONLYONETHREAD
{
ProcessTimers(pWorkQueue, &pSlistEntryHead, &pSlistEntryTail, &usCount);
}
//
// Queue any work items we accumulated in one fell swoop.
//
if (pSlistEntryHead != NULL)
{
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (usCount > 1)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumSimultaneousQueues));
}
#ifdef WINCE
LONG lCount;
lCount = usCount;
while (lCount > 0)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumWorkItems));
lCount--;
}
#else // ! WINCE
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalNumWorkItems), usCount);
#endif // ! WINCE
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNAppendListNBQueue(pWorkQueue->pvNBQueueWorkItems,
pSlistEntryHead,
OFFSETOF(CWorkItem, m_SlistEntry));
}
#ifndef DPNBUILD_ONLYONETHREAD
//
// In case other threads are running, one of them should become a timer
// thread. We will need to kick them via the alert event so that they
// notice.
//
if (fNeedToServiceTimers)
{
DPFX(DPFPREP, 8, "Abdicating timer thread responsibilities because of DoWork.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
pWorkQueue->dwTotalNumTimerThreadAbdications++;
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNASSERT(! pWorkQueue->fTimerThreadNeeded);
#pragma TODO(vanceo, "Does this truly need to be interlocked?")
fNeedToServiceTimers = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) TRUE);
DNASSERT(! fNeedToServiceTimers); // there had better not be more than one timer thread
DNSetEvent(pWorkQueue->hAlertEvent);
}
//
// Reset the tracking variables.
//
pSlistEntryHead = NULL;
usCount = 0;
#endif // ! DPNBUILD_ONLYONETHREAD
//
// Keep looping until we run out of items to do. Note that this thread
// does not try to count itself as busy. Either we are in DoWork mode
// proper where the busy thread concept has no meaning, or we are a worker
// thread processing a job that called WaitWhileWorking where
// pWorkQueue->lNumBusyThreads would already have been incremented.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
while (pWorkItem != NULL)
{
//
// Call the user's function or note that we need to stop running.
//
if (pWorkItem->m_pfnWorkCallback != NULL)
{
//
// Save the uniqueness ID to determine if this item was a timer
// that got rescheduled.
//
uiOriginalUniqueID = pWorkItem->m_uiUniqueID;
DPFX(DPFPREP, 8, "Begin executing work item 0x%p (fn = 0x%p, context = 0x%p, unique = %u, queue = 0x%p).",
pWorkItem, pWorkItem->m_pfnWorkCallback,
pWorkItem->m_pvCallbackContext, uiOriginalUniqueID,
pWorkQueue);
ThreadpoolStatsBeginExecuting(pWorkItem);
pWorkItem->m_pfnWorkCallback(pWorkItem->m_pvCallbackContext,
pWorkItem,
uiOriginalUniqueID);
//
// Return the item to the pool unless it got rescheduled. This
// assumes that the actual pWorkItem memory remains valid even
// though it may have been rescheduled and then completed/cancelled
// by the time we perform this test. See CancelTimer.
//
if (uiOriginalUniqueID == pWorkItem->m_uiUniqueID)
{
ThreadpoolStatsEndExecuting(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, returning to pool.", pWorkItem);
pWorkQueue->pWorkItemPool->Release(pWorkItem);
}
else
{
ThreadpoolStatsEndExecutingRescheduled(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, it was rescheduled.", pWorkItem);
}
}
else
{
DPFX(DPFPREP, 3, "Recognized exit thread work item 0x%p.", pWorkItem);
//
// This thread shouldn't get told to exit when either in DoWork
// mode proper, or while performing work while waiting. However,
// it is possible in the latter case to pick up a quit event
// "intended" (in a sense) for another thread. We need to resubmit
// the exit thread request so that another thread that can process
// it, will.
//
// If we just put it back on the queue now, our while loop would
// probably just pull it off again getting us nowhere. Instead, we
// will save up all of the exit requests we mistakenly receive and
// dump them all back on the queue once we've run out of things to
// do.
//
#ifdef DPNBUILD_ONLYONETHREAD
DNASSERT(FALSE);
#else // ! DPNBUILD_ONLYONETHREAD
DNASSERT(pWorkQueue->dwNumRunningThreads > 1);
if (pSlistEntryHead == NULL)
{
pSlistEntryTail = pSlistEntryHead;
}
pWorkItem->m_SlistEntry.Next = pSlistEntryHead;
pSlistEntryHead = &pWorkItem->m_SlistEntry;
usCount++;
#endif // ! DPNBUILD_ONLYONETHREAD
}
//
// Make sure we haven't exceeded our time limit (if we have one).
//
if ((dwMaxDoWorkTime != INFINITE) &&
((int) (dwMaxDoWorkTime - GETTIMESTAMP()) < 0))
{
DPFX(DPFPREP, 5, "Exceeded time limit, not processing any more work.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumDoWorksTimeLimit));
#endif // DPNBUILD_THREADPOOLSTATISTICS
break;
}
//
// Try to get the next work item.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (pWorkItem != NULL)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumContinuousWork));
}
#endif // DPNBUILD_THREADPOOLSTATISTICS
} // end while (more items)
#ifndef DPNBUILD_ONLYONETHREAD
//
// Re-queue any exit thread work items we accumulated.
//
if (pSlistEntryHead != NULL)
{
DPFX(DPFPREP, 1, "Re-queuing %u exit thread work items for queue 0x%p.",
usCount, pWorkQueue);
DNAppendListNBQueue(pWorkQueue->pvNBQueueWorkItems,
pSlistEntryHead,
OFFSETOF(CWorkItem, m_SlistEntry));
}
else
{
DNASSERT(usCount == 0);
}
#endif // ! DPNBUILD_ONLYONETHREAD
DPFX(DPFPREP, 8, "Leave");
} // DoWork
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#ifndef DPNBUILD_ONLYONETHREAD
#undef DPF_MODNAME
#define DPF_MODNAME "DPTPWorkerThreadProc"
//=============================================================================
// DPTPWorkerThreadProc
//-----------------------------------------------------------------------------
//
// Description: The standard worker thread function for executing work
// items.
//
// Arguments:
// PVOID pvParameter - Pointer to thread parameter data.
//
// Returns: DWORD
//=============================================================================
DWORD WINAPI DPTPWorkerThreadProc(PVOID pvParameter)
{
DPTPWORKQUEUE * pWorkQueue = (DPTPWORKQUEUE*) pvParameter;
DPTPWORKERTHREAD WorkerThread;
BOOL fUninitializeCOM = TRUE;
PFNDPNMESSAGEHANDLER pfnMsgHandler;
PVOID pvMsgHandlerContext;
PVOID pvUserThreadContext;
HRESULT hr;
DWORD dwResult;
#ifndef DPNBUILD_ONLYONEPROCESSOR
#if ((! defined(DPNBUILD_SOFTTHREADAFFINITY)) && (! defined(DPNBUILD_USEIOCOMPLETIONPORTS)))
DWORD_PTR dwpAffinityMask;
#endif // ! DPNBUILD_SOFTTHREADAFFINITY and ! DPNBUILD_USEIOCOMPLETIONPORTS
#ifdef DBG
SYSTEM_INFO SystemInfo;
#endif // DBG
#endif // ! DPNBUILD_ONLYONEPROCESSOR
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pvParameter);
#ifndef DPNBUILD_ONLYONEPROCESSOR
//
// Bind to a specific CPU. First, assert that the CPU number is valid in
// debug builds.
//
#ifdef DBG
GetSystemInfo(&SystemInfo);
DNASSERT(pWorkQueue->dwCPUNum < SystemInfo.dwNumberOfProcessors);
#endif // DBG
#ifndef DPNBUILD_USEIOCOMPLETIONPORTS
SetThreadIdealProcessor(GetCurrentThread(), pWorkQueue->dwCPUNum);
#ifndef DPNBUILD_SOFTTHREADAFFINITY
DNASSERT(pWorkQueue->dwCPUNum < (sizeof(dwpAffinityMask) * 8));
dwpAffinityMask = 1 << pWorkQueue->dwCPUNum;
SetThreadAffinityMask(GetCurrentThread(), dwpAffinityMask);
#endif // ! DPNBUILD_SOFTTHREADAFFINITY
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#endif // ! DPNBUILD_ONLYONEPROCESSOR
//
// Boost the thread priority.
//
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
//
// Init COM.
//
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if (FAILED(hr))
{
DPFX(DPFPREP, 0, "Failed to initialize COM (err = 0x%lx)! Continuing.", hr);
fUninitializeCOM = FALSE;
//
// Continue...
//
}
//
// Initialize the worker thread data.
//
memset(&WorkerThread, 0, sizeof(WorkerThread));
WorkerThread.Sig[0] = 'W';
WorkerThread.Sig[1] = 'K';
WorkerThread.Sig[2] = 'T';
WorkerThread.Sig[3] = 'D';
WorkerThread.pWorkQueue = pWorkQueue;
#ifdef DBG
WorkerThread.dwThreadID = GetCurrentThreadId();
WorkerThread.blList.Initialize();
DNEnterCriticalSection(&pWorkQueue->csListLock);
WorkerThread.blList.InsertBefore(&pWorkQueue->blThreadList);
DNLeaveCriticalSection(&pWorkQueue->csListLock);
#endif // DBG
//
// Save the worker thread data.
//
TlsSetValue(pWorkQueue->dwWorkerThreadTlsIndex, &WorkerThread);
dwResult = DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwNumRunningThreads));
DPFX(DPFPREP, 7, "Thread %u/0x%x from queue 0x%p started, num running threads is now %u.",
GetCurrentThreadId(), GetCurrentThreadId(), pWorkQueue, dwResult);
//
// Save the current user message handler. If there is one, call it now
// with thread initialization information.
//
pfnMsgHandler = pWorkQueue->pfnMsgHandler;
if (pfnMsgHandler != NULL)
{
DPNMSG_CREATE_THREAD MsgCreateThread;
//
// Save the message handler context.
//
pvMsgHandlerContext = pWorkQueue->pvMsgHandlerContext;
//
// Call the user's message handler with a CREATE_THREAD message.
//
MsgCreateThread.dwSize = sizeof(MsgCreateThread);
MsgCreateThread.dwFlags = 0;
#ifdef DPNBUILD_ONLYONEPROCESSOR
MsgCreateThread.dwProcessorNum = 0;
#else // ! DPNBUILD_ONLYONEPROCESSOR
MsgCreateThread.dwProcessorNum = pWorkQueue->dwCPUNum;
#endif // ! DPNBUILD_ONLYONEPROCESSOR
MsgCreateThread.pvUserContext = NULL;
hr = pfnMsgHandler(pvMsgHandlerContext,
DPN_MSGID_CREATE_THREAD,
&MsgCreateThread);
#ifdef DBG
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "User returned error 0x%08x from CREATE_THREAD indication!",
1, hr);
}
#endif // DBG
//
// Save what the user returned for a thread context.
//
pvUserThreadContext = MsgCreateThread.pvUserContext;
}
//
// The user (if any) now knows about the thread.
//
WorkerThread.fThreadIndicated = TRUE;
DNASSERT(pWorkQueue->dwNumThreadsExpected > 0);
dwResult = DNInterlockedDecrement((LPLONG) (&pWorkQueue->dwNumThreadsExpected));
if (dwResult == 0)
{
DPFX(DPFPREP, 9, "All threads expected to start have, setting event.");
DNASSERT(pWorkQueue->hExpectedThreadsEvent != NULL);
DNSetEvent(pWorkQueue->hExpectedThreadsEvent); // ignore error
}
else
{
DPFX(DPFPREP, 9, "Number of threads expected to start is now %u.", dwResult);
}
//
// Perform the work loop.
//
DPTPWorkerLoop(pWorkQueue);
//
// The user (if any) is about to be told about the thread's destruction.
//
WorkerThread.fThreadIndicated = FALSE;
//
// If there was a user message handler, call it now with thread shutdown
// information.
//
if (pfnMsgHandler != NULL)
{
DPNMSG_DESTROY_THREAD MsgDestroyThread;
//
// Call the user's message handler with a DESTROY_THREAD message.
//
MsgDestroyThread.dwSize = sizeof(MsgDestroyThread);
#ifdef DPNBUILD_ONLYONEPROCESSOR
MsgDestroyThread.dwProcessorNum = 0;
#else // ! DPNBUILD_ONLYONEPROCESSOR
MsgDestroyThread.dwProcessorNum = pWorkQueue->dwCPUNum;
#endif // ! DPNBUILD_ONLYONEPROCESSOR
MsgDestroyThread.pvUserContext = pvUserThreadContext;
hr = pfnMsgHandler(pvMsgHandlerContext,
DPN_MSGID_DESTROY_THREAD,
&MsgDestroyThread);
#ifdef DBG
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "User returned error 0x%08x from DESTROY_THREAD indication!",
1, hr);
}
#endif // DBG
pfnMsgHandler = NULL;
pvMsgHandlerContext = NULL;
pvUserThreadContext = NULL;
}
#ifdef DBG
DNEnterCriticalSection(&pWorkQueue->csListLock);
WorkerThread.blList.RemoveFromList();
DNLeaveCriticalSection(&pWorkQueue->csListLock);
DNASSERT(WorkerThread.dwRecursionCount == 0);
DNASSERT(TlsGetValue(pWorkQueue->dwWorkerThreadTlsIndex) == &WorkerThread);
#endif // DBG
DNASSERT(pWorkQueue->dwNumRunningThreads > 0);
dwResult = DNInterlockedDecrement((LPLONG) (&pWorkQueue->dwNumRunningThreads));
DPFX(DPFPREP, 7, "Thread %u/0x%x from queue 0x%p done, num running threads is now %u.",
GetCurrentThreadId(), GetCurrentThreadId(), pWorkQueue, dwResult);
#ifndef WINCE
CancelIoForThisThread(pWorkQueue);
#endif // ! WINCE
if (fUninitializeCOM)
{
CoUninitialize();
fUninitializeCOM = FALSE;
}
DNASSERT(pWorkQueue->dwNumThreadsExpected > 0);
dwResult = DNInterlockedDecrement((LPLONG) (&pWorkQueue->dwNumThreadsExpected));
if (dwResult == 0)
{
DPFX(DPFPREP, 9, "All threads expected to stop have, setting event.");
DNASSERT(pWorkQueue->hExpectedThreadsEvent != NULL);
DNSetEvent(pWorkQueue->hExpectedThreadsEvent); // ignore error
}
else
{
DPFX(DPFPREP, 9, "Number of threads expected to stop is now %u.", dwResult);
}
//
// Since we have decremented dwNumRunningThreads and possibly set the
// event, any other threads waiting on that will think we are gone.
// Therefore, we cannot use pWorkQueue after this as it may have been
// deallocated. We must also endeavor to do as little work as possible
// because there is a race condition where the module in which this code
// resides could be unloaded.
//
DPFX(DPFPREP, 6, "Leave");
return 0;
} // DPTPWorkerThreadProc
#ifdef DPNBUILD_MANDATORYTHREADS
#undef DPF_MODNAME
#define DPF_MODNAME "DPTPMandatoryThreadProc"
//=============================================================================
// DPTPMandatoryThreadProc
//-----------------------------------------------------------------------------
//
// Description: The standard worker thread function for executing work
// items.
//
// Arguments:
// PVOID pvParameter - Pointer to thread parameter data.
//
// Returns: DWORD
//=============================================================================
DWORD WINAPI DPTPMandatoryThreadProc(PVOID pvParameter)
{
DPTPMANDATORYTHREAD * pMandatoryThread = (DPTPMANDATORYTHREAD*) pvParameter;
DPTHREADPOOLOBJECT * pDPTPObject;
PFNDPNMESSAGEHANDLER pfnMsgHandler;
PVOID pvMsgHandlerContext;
PVOID pvUserThreadContext;
HRESULT hr;
DWORD dwResult;
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pvParameter);
//
// Save a copy of the local object.
//
pDPTPObject = pMandatoryThread->pDPTPObject;
#ifdef DBG
//
// Store the thread ID.
//
pMandatoryThread->dwThreadID = GetCurrentThreadId();
#endif // DBG
//
// Take the lock, and then ensure we aren't in DoWork mode.
//
DNEnterCriticalSection(&pDPTPObject->csLock);
if (pDPTPObject->dwTotalUserThreadCount == 0)
{
//
// Bail out of this function. The thread starting us still owns the
// pMandatoryThread memory and will handle this failure correctly.
//
DNLeaveCriticalSection(&pDPTPObject->csLock);
return DPNERR_NOTALLOWED;
}
//
// Increment the thread count. We use interlocked increment because we can
// touch the counter outside of the lock below.
//
DNASSERT(pDPTPObject->dwMandatoryThreadCount != -1);
DNInterlockedIncrement((LPLONG) (&pDPTPObject->dwMandatoryThreadCount));
#ifdef DBG
//
// Add this thread to the list of tracked threads.
//
pMandatoryThread->blList.InsertBefore(&pDPTPObject->blMandatoryThreads);
#endif // DBG
DNLeaveCriticalSection(&pDPTPObject->csLock);
//
// Save the current user message handler. If there is one, call it now
// with thread initialization information.
//
pfnMsgHandler = pMandatoryThread->pfnMsgHandler;
if (pfnMsgHandler != NULL)
{
DPNMSG_CREATE_THREAD MsgCreateThread;
//
// Save the message handler context.
//
pvMsgHandlerContext = pMandatoryThread->pvMsgHandlerContext;
//
// Call the user's message handler with a CREATE_THREAD message.
//
MsgCreateThread.dwSize = sizeof(MsgCreateThread);
MsgCreateThread.dwFlags = DPNTHREAD_MANDATORY;
MsgCreateThread.dwProcessorNum = -1;
MsgCreateThread.pvUserContext = NULL;
hr = pfnMsgHandler(pvMsgHandlerContext,
DPN_MSGID_CREATE_THREAD,
&MsgCreateThread);
#ifdef DBG
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "User returned error 0x%08x from CREATE_THREAD indication!",
1, hr);
}
#endif // DBG
//
// Save what the user returned for a thread context.
//
pvUserThreadContext = MsgCreateThread.pvUserContext;
}
//
// Alert the creator thread. After this call, we own the pMandatoryThread
// memory.
//
DPFX(DPFPREP, 9, "Thread created successfully, setting event.");
DNASSERT(pMandatoryThread->hStartedEvent != NULL);
DNSetEvent(pMandatoryThread->hStartedEvent); // ignore error
//
// Call the user's thread proc function.
//
DPFX(DPFPREP, 2, "Calling user thread function 0x%p with parameter 0x%p.",
pMandatoryThread->lpStartAddress, pMandatoryThread->lpParameter);
dwResult = pMandatoryThread->lpStartAddress(pMandatoryThread->lpParameter);
DPFX(DPFPREP, 2, "Returning from user thread with result %u/0x%x.",
dwResult, dwResult);
//
// If there was a user message handler, call it now with thread shutdown
// information.
//
if (pfnMsgHandler != NULL)
{
DPNMSG_DESTROY_THREAD MsgDestroyThread;
//
// Call the user's message handler with a DESTROY_THREAD message.
//
MsgDestroyThread.dwSize = sizeof(MsgDestroyThread);
MsgDestroyThread.dwProcessorNum = -1;
MsgDestroyThread.pvUserContext = pvUserThreadContext;
hr = pfnMsgHandler(pvMsgHandlerContext,
DPN_MSGID_DESTROY_THREAD,
&MsgDestroyThread);
#ifdef DBG
if (hr != DPN_OK)
{
DPFX(DPFPREP, 0, "User returned error 0x%08x from DESTROY_THREAD indication!",
1, hr);
}
#endif // DBG
pfnMsgHandler = NULL;
pvMsgHandlerContext = NULL;
pvUserThreadContext = NULL;
}
//
// Assert that the thread pool object is still valid.
//
DNASSERT((pDPTPObject->Sig[0] == 'D') && (pDPTPObject->Sig[1] == 'P') && (pDPTPObject->Sig[2] == 'T') && (pDPTPObject->Sig[3] == 'P'));
#ifdef DBG
//
// Remove this thread from the list of tracked threads.
//
DNEnterCriticalSection(&pDPTPObject->csLock);
pMandatoryThread->blList.RemoveFromList();
DNLeaveCriticalSection(&pDPTPObject->csLock);
#endif // DBG
//
// Release the object resources.
//
DNFree(pMandatoryThread);
pMandatoryThread = NULL;
DPFX(DPFPREP, 6, "Leave (mandatory thread count was approximately %u)",
pDPTPObject->dwMandatoryThreadCount);
//
// Signal to the object that this thread is gone. There is a race
// condition because we've set the counter, but there are a non-zero number
// of instructions we still have to execute before this thread is truly
// gone. COM has a similar race condition, and if the live with it, so can
// we. Because we want to minimize the number of instructions afterward,
// note that we use interlocked decrement outside of the critical section.
//
DNASSERT(pDPTPObject->dwMandatoryThreadCount > 0);
DNInterlockedDecrement((LPLONG) (&pDPTPObject->dwMandatoryThreadCount));
return dwResult;
} // DPTPMandatoryThreadProc
#endif // DPNBUILD_MANDATORYTHREADS
#undef DPF_MODNAME
#define DPF_MODNAME "DPTPWorkerLoop"
//=============================================================================
// DPTPWorkerLoop
//-----------------------------------------------------------------------------
//
// Description: The worker thread looping function for executing work items.
//
// Arguments:
// DPTPWORKQUEUE * pWorkQueue - Pointer to work queue object to use.
//
// Returns: None.
//=============================================================================
void DPTPWorkerLoop(DPTPWORKQUEUE * const pWorkQueue)
#ifdef DPNBUILD_USEIOCOMPLETIONPORTS
{
BOOL fShouldRun = TRUE;
BOOL fRunningAsTimerThread = FALSE;
DWORD dwBytesTransferred;
DWORD dwCompletionKey;
OVERLAPPED * pOverlapped;
CWorkItem * pWorkItem;
DWORD dwNumBusyThreads;
DWORD dwNumRunningThreads;
BOOL fResult;
UINT uiOriginalUniqueID;
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
DWORD dwStartTime;
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pWorkQueue);
//
// Keep looping until we're told to exit.
//
while (fShouldRun)
{
//
// If we're not already running as a timer thread, atomically see if
// there is currently a timer thread, and become it if not.
// There can be only one.
//
if (! fRunningAsTimerThread)
{
fRunningAsTimerThread = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) FALSE);
#ifdef DBG
if (fRunningAsTimerThread)
{
DPFX(DPFPREP, 9, "Becoming timer thread.");
}
#endif // DBG
}
//
// If we're the timer thread, wake up periodically to service timers by
// waiting on a waitable timer object. Otherwise, wait for a queue
// item.
//
if (fRunningAsTimerThread)
{
DWORD dwResult;
//DPFX(DPFPREP, 9, "Waiting on timer handle 0x%p.", pWorkQueue->hTimer);
dwResult = DNWaitForSingleObject(pWorkQueue->hTimer, INFINITE);
DNASSERT(dwResult == WAIT_OBJECT_0);
//
// Handle any expired or cancelled timer entries.
//
ProcessTimers(pWorkQueue);
//
// Increase the number of busy threads.
//
dwNumBusyThreads = DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwNumBusyThreads));
//
// Grab the current total thread count.
//
dwNumRunningThreads = *((volatile DWORD *) (&pWorkQueue->dwNumRunningThreads));
//
// If there are other threads, we won't attempt to process work
// unless they're all busy.
//
if ((dwNumRunningThreads == 1) || (dwNumBusyThreads == dwNumRunningThreads))
{
#ifdef DBG
if (dwNumRunningThreads > 1) // reduce spew when only running 1 thread
{
DPFX(DPFPREP, 9, "No idle threads (busy = %u), may become worker thread.",
dwNumBusyThreads);
}
#endif // DBG
#pragma TODO(vanceo, "Optimize single thread case (right now we only process one item per timer bucket)")
//
// See if there's any work to do at the moment.
//
fResult = GetQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
&dwBytesTransferred,
&dwCompletionKey,
&pOverlapped,
0);
if ((fResult) || (pOverlapped != NULL))
{
pWorkItem = CONTAINING_OBJECT(pOverlapped, CWorkItem, m_Overlapped);
DNASSERT(pWorkItem->IsValid());
DPFX(DPFPREP, 8, "Abdicating timer thread responsibilities.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
pWorkQueue->dwTotalNumTimerThreadAbdications++;
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNASSERT(! pWorkQueue->fTimerThreadNeeded);
#pragma TODO(vanceo, "Does this truly need to be interlocked?")
fRunningAsTimerThread = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) TRUE);
DNASSERT(! fRunningAsTimerThread); // there had better not be more than one timer thread
//
// Call the user's function or note that we may need to
// stop running.
//
if (pWorkItem->m_pfnWorkCallback != NULL)
{
//
// Save the uniqueness ID to determine if this item was
// a timer that got rescheduled.
//
uiOriginalUniqueID = pWorkItem->m_uiUniqueID;
DPFX(DPFPREP, 8, "Begin executing work item 0x%p (fn = 0x%p, context = 0x%p, unique = %u, queue = 0x%p) as previous timer thread.",
pWorkItem, pWorkItem->m_pfnWorkCallback,
pWorkItem->m_pvCallbackContext, uiOriginalUniqueID,
pWorkQueue);
ThreadpoolStatsBeginExecuting(pWorkItem);
pWorkItem->m_pfnWorkCallback(pWorkItem->m_pvCallbackContext,
pWorkItem,
uiOriginalUniqueID);
//
// Return the item to the pool unless it got
// rescheduled. This assumes that the actual pWorkItem
// memory remains valid even though it may have been
// rescheduled and then completed/cancelled by the time
// we perform this test. See CancelTimer.
//
if (uiOriginalUniqueID == pWorkItem->m_uiUniqueID)
{
ThreadpoolStatsEndExecuting(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, returning to pool.", pWorkItem);
pWorkQueue->pWorkItemPool->Release(pWorkItem);
}
else
{
ThreadpoolStatsEndExecutingRescheduled(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, it was rescheduled.", pWorkItem);
}
}
else
{
//
// If there are any other threads, requeue the kill
// thread work item, otherwise, quit.
//
if (dwNumRunningThreads > 1)
{
DPFX(DPFPREP, 3, "Requeuing exit thread work item 0x%p for other threads.",
pWorkItem);
fResult = PostQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
0,
0,
&pWorkItem->m_Overlapped);
DNASSERT(fResult);
}
else
{
DPFX(DPFPREP, 3, "Recognized exit thread work item 0x%p as previous timer thread.",
pWorkItem);
//
// Return the item to the pool.
//
pWorkQueue->pWorkItemPool->Release(pWorkItem);
//
// Bail out of the 'while' loop.
//
fShouldRun = FALSE;
}
}
}
else
{
//
// No queued work at the moment.
//
}
}
else
{
//DPFX(DPFPREP, 9, "Other non-busy threads exist, staying as timer thread (busy = %u, total = %u).", dwNumBusyThreads, dwNumRunningThreads);
}
}
else
{
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
dwStartTime = GETTIMESTAMP();
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
//DPFX(DPFPREP, 9, "Getting queued packet on completion port 0x%p.", pWorkQueue->hIoCompletionPort);
fResult = GetQueuedCompletionStatus(HANDLE_FROM_DNHANDLE(pWorkQueue->hIoCompletionPort),
&dwBytesTransferred,
&dwCompletionKey,
&pOverlapped,
INFINITE);
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalTimeSpentUnsignalled),
(GETTIMESTAMP() - dwStartTime));
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
DNASSERT(pOverlapped != NULL);
pWorkItem = CONTAINING_OBJECT(pOverlapped, CWorkItem, m_Overlapped);
DNASSERT(pWorkItem->IsValid());
//
// Increase the number of busy threads.
//
dwNumBusyThreads = DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwNumBusyThreads));
//
// Call the user's function or note that we need to stop running.
//
if (pWorkItem->m_pfnWorkCallback != NULL)
{
//
// Save the uniqueness ID to determine if this item was a timer
// that got rescheduled.
//
uiOriginalUniqueID = pWorkItem->m_uiUniqueID;
DPFX(DPFPREP, 8, "Begin executing work item 0x%p (fn = 0x%p, context = 0x%p, unique = %u, queue = 0x%p) as worker thread.",
pWorkItem, pWorkItem->m_pfnWorkCallback,
pWorkItem->m_pvCallbackContext, uiOriginalUniqueID,
pWorkQueue);
ThreadpoolStatsBeginExecuting(pWorkItem);
pWorkItem->m_pfnWorkCallback(pWorkItem->m_pvCallbackContext,
pWorkItem,
uiOriginalUniqueID);
//
// Return the item to the pool unless it got rescheduled. This
// assumes that the actual pWorkItem memory remains valid even
// though it may have been rescheduled and then completed/
// cancelled by the time we perform this test. See
// CancelTimer.
//
if (uiOriginalUniqueID == pWorkItem->m_uiUniqueID)
{
ThreadpoolStatsEndExecuting(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, returning to pool.", pWorkItem);
pWorkQueue->pWorkItemPool->Release(pWorkItem);
}
else
{
ThreadpoolStatsEndExecutingRescheduled(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, it was rescheduled.", pWorkItem);
}
}
else
{
DPFX(DPFPREP, 3, "Recognized exit thread work item 0x%p as worker thread.",
pWorkItem);
//
// Return the item to the pool.
//
pWorkQueue->pWorkItemPool->Release(pWorkItem);
//
// Bail out of the 'while' loop.
//
fShouldRun = FALSE;
}
}
//
// Revert the busy count.
//
DNInterlockedDecrement((LPLONG) (&pWorkQueue->dwNumBusyThreads));
} // end while (should keep running)
DPFX(DPFPREP, 6, "Leave");
} // DPTPWorkerLoop
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#else // ! DPNBUILD_USEIOCOMPLETIONPORTS
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
{
BOOL fShouldRun = TRUE;
BOOL fRunningAsTimerThread = FALSE;
BOOL fSetAndWait = FALSE;
DNSLIST_ENTRY * pSlistEntryHead;
DNSLIST_ENTRY * pSlistEntryTail;
USHORT usCount;
DWORD dwNumBusyThreads;
DWORD dwNumRunningThreads;
CWorkItem * pWorkItem;
DWORD dwResult;
DWORD dwWaitTimeout;
DNHANDLE hWaitObject;
UINT uiOriginalUniqueID;
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
DWORD dwStartTime;
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
DPFX(DPFPREP, 6, "Parameters: (0x%p)", pWorkQueue);
//
// When we can't use waitable timers, we always wait on the same object,
// but the timeout can differ. If we can use waitable timers, the timeout
// is always INFINITE.
//
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
dwWaitTimeout = INFINITE;
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
hWaitObject = pWorkQueue->hAlertEvent;
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
//
// Keep looping until we're told to exit.
//
while (fShouldRun)
{
//
// We also have an additional optimization technique that attempts to
// minimize the amount that the timer responsibility passes from thread
// to thread. It only truly works on NT, because of the atomic
// SignalObjectAndWait function. Having separate SetEvent and Wait
// operations could mean an extra context switch: SetEvent causes a
// waiting thread to take over, then when the timer thread is activated
// again, it just goes back to waiting.
//
// But we'll still execute the code on 9x (when we can use waitable
// timers). The real problem is on CE, where the event to set and the
// event on which the timer thread waits are the same, so it would
// almost certainly just be waking itself up. So if we're not using
// waitable timers, we set the event at a different location in an
// attempt to reduce this possibility.
//
// You'll probably need to understand the rest of this function for
// this "optimization" to make much sense.
//
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
if (fSetAndWait)
{
DNASSERT(fRunningAsTimerThread);
DPFX(DPFPREP, 8, "Signalling event 0x%p and waiting on timer 0x%p.",
pWorkQueue->hAlertEvent, pWorkQueue->hTimer);
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
dwStartTime = GETTIMESTAMP();
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
dwResult = DNSignalObjectAndWait(pWorkQueue->hAlertEvent,
pWorkQueue->hTimer,
INFINITE,
FALSE);
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalTimeSpentUnsignalled),
(GETTIMESTAMP() - dwStartTime));
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
//
// Clear the flag.
//
fSetAndWait = FALSE;
}
else
#endif // WINNT or (WIN95 and ! DPNBUILD_NOWAITABLETIMERSON9X)
{
//
// If we're not already running as a timer thread, atomically see
// if there is currently a timer thread, and become it if not.
// There can be only one.
//
if (! fRunningAsTimerThread)
{
fRunningAsTimerThread = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) FALSE);
#ifdef DBG
if (fRunningAsTimerThread)
{
DPFX(DPFPREP, 9, "Becoming timer thread.");
}
#endif // DBG
}
//
// Normally we wait for a work item. If we're the timer thread, we
// need to wake up at regular intervals to service any timer
// entries. On CE, that is done by using a timeout value for our
// Wait operation. On desktop, we use a waitable timer object.
//
if (fRunningAsTimerThread)
{
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
hWaitObject = pWorkQueue->hTimer;
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
dwWaitTimeout = TIMER_BUCKET_GRANULARITY(pWorkQueue);
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
}
else
{
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
hWaitObject = pWorkQueue->hAlertEvent;
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
dwWaitTimeout = INFINITE;
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
}
//DPFX(DPFPREP, 9, "Waiting on handle 0x%p for %i ms.", hWaitObject, (int) dwWaitTimeout);
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
dwStartTime = GETTIMESTAMP();
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
dwResult = DNWaitForSingleObject(hWaitObject, dwWaitTimeout);
#if ((defined(DPNBUILD_THREADPOOLSTATISTICS)) && (! defined(WINCE)))
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalTimeSpentUnsignalled),
(GETTIMESTAMP() - dwStartTime));
#endif // DPNBUILD_THREADPOOLSTATISTICS and ! WINCE
}
DNASSERT((dwResult == WAIT_OBJECT_0) || (dwResult == WAIT_TIMEOUT));
//
// Prepare to collect some work items that need to be queued.
//
pSlistEntryHead = NULL;
usCount = 0;
#ifndef WINCE
//
// Handle any I/O completions.
//
ProcessIo(pWorkQueue, &pSlistEntryHead, &pSlistEntryTail, &usCount);
#endif // ! WINCE
//
// If we're acting as the timer thread, retrieve any expired or
// cancelled timer entries.
//
if (fRunningAsTimerThread)
{
ProcessTimers(pWorkQueue, &pSlistEntryHead, &pSlistEntryTail, &usCount);
}
//
// Queue any work items we accumulated in one fell swoop.
//
if (pSlistEntryHead != NULL)
{
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (usCount > 1)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumSimultaneousQueues));
}
#ifdef WINCE
LONG lCount;
lCount = usCount;
while (lCount > 0)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumWorkItems));
lCount--;
}
#else // ! WINCE
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalNumWorkItems), usCount);
#endif // ! WINCE
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNAppendListNBQueue(pWorkQueue->pvNBQueueWorkItems,
pSlistEntryHead,
OFFSETOF(CWorkItem, m_SlistEntry));
}
//
// Increase the number of busy threads.
//
dwNumBusyThreads = DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwNumBusyThreads));
//
// We may be able to optimize context switching for the timer thread,
// so treat it differently. Worker threads should just go straight to
// running through the queue (if possible).
//
if (fRunningAsTimerThread)
{
//
// Grab the current total thread count.
//
dwNumRunningThreads = *((volatile DWORD *) (&pWorkQueue->dwNumRunningThreads));
//
// If we didn't add any work items, there's no point in this timer
// thread looking for jobs to execute. If we found one, we'd have
// to wake another thread so it could become the timer thread while
// we processed the item, and thus incur a context switch.
// Besides, if someone other than us added any work, they would
// have set the alert event already.
//
// There are two exceptions to that rule. One is if there is only
// this one thread, in which case we must process any work items
// because there's no one else who can. The other is on platforms
// without waitable timers. In that case, we may have dropped
// through not because the time elapsed, but rather because the
// event was set. So to prevent us from eating these alerts, we
// will check for any work to do.
//
if ((usCount == 0) && (dwNumRunningThreads > 1))
{
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
//DPFX(DPFPREP, 9, "No work items added, staying as timer thread (busy = %u, total = %u).", dwNumBusyThreads, dwNumRunningThreads);
//
// Don't execute any work.
//
pWorkItem = NULL;
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
//
// See the comments above and below. If we find something to
// do, we need to try to make another thread the timer thread
// while we work on this item.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
if (pWorkItem != NULL)
{
DPFX(DPFPREP, 9, "No work items added, but there's some in the queue, becoming worker thread (busy = %u, total = %u).",
dwNumBusyThreads, dwNumRunningThreads);
fSetAndWait = TRUE;
}
else
{
//DPFX(DPFPREP, 9, "No work items, staying as timer thread (busy = %u, total = %u).", dwNumBusyThreads, dwNumRunningThreads);
}
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
}
else
{
//
// We added work, so we may need to notify other threads.
//
// If it appears that there are enough idle threads to handle
// the work that we added, don't bother executing any work in
// this timer thread. We will need to alert other threads
// about the work, but as stated above, we would need to wake
// another thread anyway even if we did execute it in this
// thread. On NT, we get a nice optimization that allows us to
// alert a thread and go to sleep atomically (see above), so
// it's not too painful.
//
// Otherwise, all other threads are busy, so we should just
// execute the work in this thread. The first thread to
// complete the work will become the new timer thread.
//
if (dwNumBusyThreads < dwNumRunningThreads)
{
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
DPFX(DPFPREP, 9, "Other non-busy threads exist, staying as timer thread (busy = %u, total = %u, added %u items).",
dwNumBusyThreads,
dwNumRunningThreads,
usCount);
//
// Don't execute any work, and set the event up top.
//
pWorkItem = NULL;
fSetAndWait = TRUE;
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
//
// Because CE sets and waits on the same event, we opt to
// make this timer thread a worker thread anyway, and set
// the alert event sooner. See comments at the top and
// down below for more details.
//
// So attempt to pop the next work item off the stack.
// Note that theoretically all of the work we added could
// have been processed already, so we might still end up
// with nothing to do. Don't enable fSetAndWait if that's
// the case.
//
DPFX(DPFPREP, 9, "Trying to become worker thread (busy = %u, total = %u, added %u items).",
dwNumBusyThreads,
dwNumRunningThreads,
usCount);
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
if (pWorkItem != NULL)
{
fSetAndWait = TRUE;
}
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
}
else
{
#ifdef DBG
if (dwNumRunningThreads > 1) // reduce spew when only running 1 thread
{
DPFX(DPFPREP, 9, "No idle threads (busy = %u) after adding %u items, may become worker thread.",
dwNumBusyThreads, usCount);
}
#endif // DBG
//
// Attempt to pop the next work item off the stack.
// Note that theoretically all of the work we added could
// have been processed already, so we could end up with
// nothing to do.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
}
} // end else (added work from timers or I/O)
}
else
{
//
// Not a timer thread. Attempt to pop the next work item off the
// stack, if any.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (pWorkItem == NULL)
{
DPFX(DPFPREP, 7, "No items for worker thread (busy = %u, had added %u items to queue 0x%p).",
dwNumBusyThreads, usCount, pWorkQueue);
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumWakesWithoutWork));
}
#endif // DPNBUILD_THREADPOOLSTATISTICS
}
//
// Execute as many work items in a row as possible.
//
while (pWorkItem != NULL)
{
//
// If we were acting as the timer thread, we need another thread to
// take over that responsibility while we're busy processing what
// could be a long work item.
//
if (fRunningAsTimerThread)
{
DPFX(DPFPREP, 8, "Abdicating timer thread responsibilities.");
#ifdef DPNBUILD_THREADPOOLSTATISTICS
//
// Update the debugging/tuning statistics.
//
pWorkQueue->dwTotalNumTimerThreadAbdications++;
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNASSERT(! pWorkQueue->fTimerThreadNeeded);
#pragma TODO(vanceo, "Does this truly need to be interlocked?")
fRunningAsTimerThread = DNInterlockedExchange((LPLONG) (&pWorkQueue->fTimerThreadNeeded),
(LONG) TRUE);
DNASSERT(! fRunningAsTimerThread); // there had better not be more than one timer thread
//
// On CE (or 9x, if we're not using waitable timers), we may
// also need to kick other threads so that they notice there's
// no timer thread any more. We endure SetEvent's unfortunate
// context switch because if this turned out to be a really
// long job, and no I/O or newly queued work items jolt the
// other threads out of their Waits, timers could go unserviced
// until this thread finishes. We choose to have more accurate
// timers.
//
// We do this now because it's more efficient to switch to
// another thread now than run the risk of just alerting
// ourselves (see the comments at the top of this function).
//
// On desktop, we should only get in here if we couldn't alert
// any other threads, so it wouldn't make sense to SetEvent.
//
#pragma TODO(vanceo, "We may be able to live with some possible loss of timer response, if we could assume we'll get I/O or queued work items")
#if ((defined(WINNT)) || ((defined(WIN95)) && (! defined(DPNBUILD_NOWAITABLETIMERSON9X))))
DNASSERT(! fSetAndWait);
#else // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
if (fSetAndWait)
{
DNSetEvent(pWorkQueue->hAlertEvent); // ignore potential failure, there's nothing we could do
fSetAndWait = FALSE;
}
#endif // ! WINNT and (! WIN95 or DPNBUILD_NOWAITABLETIMERSON9X)
}
//
// Call the user's function or note that we need to stop running.
//
if (pWorkItem->m_pfnWorkCallback != NULL)
{
//
// Save the uniqueness ID to determine if this item was a timer
// that got rescheduled.
//
uiOriginalUniqueID = pWorkItem->m_uiUniqueID;
DPFX(DPFPREP, 8, "Begin executing work item 0x%p (fn = 0x%p, context = 0x%p, unique = %u, queue = 0x%p).",
pWorkItem, pWorkItem->m_pfnWorkCallback,
pWorkItem->m_pvCallbackContext, uiOriginalUniqueID,
pWorkQueue);
ThreadpoolStatsBeginExecuting(pWorkItem);
pWorkItem->m_pfnWorkCallback(pWorkItem->m_pvCallbackContext,
pWorkItem,
uiOriginalUniqueID);
//
// Return the item to the pool unless it got rescheduled. This
// assumes that the actual pWorkItem memory remains valid even
// though it may have been rescheduled and then completed/
// cancelled by the time we perform this test. See
// CancelTimer.
//
if (uiOriginalUniqueID == pWorkItem->m_uiUniqueID)
{
ThreadpoolStatsEndExecuting(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, returning to pool.", pWorkItem);
pWorkQueue->pWorkItemPool->Release(pWorkItem);
}
else
{
ThreadpoolStatsEndExecutingRescheduled(pWorkItem);
DPFX(DPFPREP, 8, "Done executing work item 0x%p, it was rescheduled.", pWorkItem);
}
}
else
{
DPFX(DPFPREP, 3, "Recognized exit thread work item 0x%p.",
pWorkItem);
//
// Return the item to the pool.
//
pWorkQueue->pWorkItemPool->Release(pWorkItem);
//
// We're about to bail out of the processing loop, so we need
// other threads to notice. It's possible that all threads
// were busy so that the alert event was set twice before any
// thread noticed it, and only this thread was released. In
// that case, we need the other threads to start processing.
//
if (! DNIsNBQueueEmpty(pWorkQueue->pvNBQueueWorkItems))
{
DNSetEvent(pWorkQueue->hAlertEvent); // ignore potential failure, there's nothing we could do
}
//
// Bail out of both 'while' loops.
//
fShouldRun = FALSE;
break;
}
#ifndef WINCE
//
// Handle any I/O completions that came in while we were working.
//
pSlistEntryHead = NULL;
usCount = 0;
ProcessIo(pWorkQueue, &pSlistEntryHead, &pSlistEntryTail, &usCount);
//
// Queue any I/O operations that completed.
//
if (pSlistEntryHead != NULL)
{
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (usCount > 1)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumSimultaneousQueues));
}
DNInterlockedExchangeAdd((LPLONG) (&pWorkQueue->dwTotalNumWorkItems), usCount);
#endif // DPNBUILD_THREADPOOLSTATISTICS
DNAppendListNBQueue(pWorkQueue->pvNBQueueWorkItems,
pSlistEntryHead,
OFFSETOF(CWorkItem, m_SlistEntry));
}
#endif // ! WINCE
//
// Look for another work item.
//
pWorkItem = (CWorkItem*) DNRemoveHeadNBQueue(pWorkQueue->pvNBQueueWorkItems);
#ifdef DPNBUILD_THREADPOOLSTATISTICS
if (pWorkItem != NULL)
{
DNInterlockedIncrement((LPLONG) (&pWorkQueue->dwTotalNumContinuousWork));
}
#endif // DPNBUILD_THREADPOOLSTATISTICS
} // end while (more work items)
//
// Revert the busy count.
//
DNInterlockedDecrement((LPLONG) (&pWorkQueue->dwNumBusyThreads));
} // end while (should keep running)
DPFX(DPFPREP, 6, "Leave");
} // DPTPWorkerLoop
#endif // ! DPNBUILD_USEIOCOMPLETIONPORTS
#endif // ! DPNBUILD_ONLYONETHREAD