|
|
|
/*==LICENSE==*
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
Additional permissions under GNU GPL version 3 section 7
|
|
|
|
|
|
|
|
If you modify this Program, or any covered work, by linking or
|
|
|
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
|
|
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
|
|
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
|
|
|
(or a modified version of those libraries),
|
|
|
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
|
|
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
|
|
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
|
|
|
licensors of this Program grant you additional
|
|
|
|
permission to convey the resulting work. Corresponding Source for a
|
|
|
|
non-source form of such a combination shall include the source code for
|
|
|
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
|
|
|
work.
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
or by snail mail at:
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
14617 N Newport Hwy
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
*==LICENSE==*/
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* $/Plasma20/Sources/Plasma/NucleusLib/pnAsyncCoreExe/Private/W9x/pnAceW9xThread.cpp
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include "../../Pch.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
#include "pnAceW9xInt.h"
|
|
|
|
|
|
|
|
|
|
|
|
namespace W9x {
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* Private data
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
const unsigned kThreadCount = 2;
|
|
|
|
|
|
|
|
static CCritSect s_critSect;
|
|
|
|
static bool s_destroying;
|
|
|
|
static HANDLE s_destroyEvent;
|
|
|
|
static unsigned s_sequence;
|
|
|
|
static HANDLE s_shutdownEvent;
|
|
|
|
static HANDLE s_signalEvent;
|
|
|
|
static HANDLE s_thread[kThreadCount];
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* ThreadWaitRec
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
struct ThreadWaitRec {
|
|
|
|
HANDLE event;
|
|
|
|
LINK(ThreadWaitRec) link;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* CThreadDispRec
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
class CThreadDispRec {
|
|
|
|
private:
|
|
|
|
CThreadDispObject * m_object;
|
|
|
|
void * m_op;
|
|
|
|
AsyncId m_ioId;
|
|
|
|
LISTDECL(ThreadWaitRec, link) m_waitList;
|
|
|
|
|
|
|
|
public:
|
|
|
|
LINK(CThreadDispRec) m_link;
|
|
|
|
|
|
|
|
CThreadDispRec (
|
|
|
|
CThreadDispObject * object,
|
|
|
|
void * op,
|
|
|
|
AsyncId * asyncId
|
|
|
|
);
|
|
|
|
~CThreadDispRec ();
|
|
|
|
|
|
|
|
void Complete (CCritSect * critSect);
|
|
|
|
AsyncId GetId () const { return m_ioId; }
|
|
|
|
void LinkWait (ThreadWaitRec * wait);
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
static LISTDECL(CThreadDispRec, m_link) s_dispList;
|
|
|
|
static LISTDECL(CThreadDispRec, m_link) s_dispInProcList;
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
CThreadDispRec::CThreadDispRec (
|
|
|
|
CThreadDispObject * object,
|
|
|
|
void * op,
|
|
|
|
AsyncId * asyncId
|
|
|
|
) :
|
|
|
|
m_object(object),
|
|
|
|
m_op(op)
|
|
|
|
{
|
|
|
|
s_critSect.Enter();
|
|
|
|
|
|
|
|
// Verify that this module is not being destroyed
|
|
|
|
ASSERT(!s_destroying);
|
|
|
|
|
|
|
|
// Increment the owning object's reference count
|
|
|
|
object->IncRef();
|
|
|
|
|
|
|
|
// Assign an id
|
|
|
|
m_ioId = (AsyncId)++s_sequence;
|
|
|
|
if (!m_ioId)
|
|
|
|
m_ioId = (AsyncId)++s_sequence;
|
|
|
|
*asyncId = m_ioId;
|
|
|
|
|
|
|
|
// Link this record to the dispatch list
|
|
|
|
s_dispList.Link(this);
|
|
|
|
|
|
|
|
s_critSect.Leave();
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
CThreadDispRec::~CThreadDispRec () {
|
|
|
|
|
|
|
|
// Delete the operation data
|
|
|
|
CThreadDispObject * object = m_object;
|
|
|
|
object->Delete(m_op);
|
|
|
|
|
|
|
|
s_critSect.Enter();
|
|
|
|
|
|
|
|
// Unlink this record
|
|
|
|
m_link.Unlink();
|
|
|
|
|
|
|
|
// Wake up all threads blocking on this operation. We must unlink each
|
|
|
|
// wait record before we signal it.
|
|
|
|
for (ThreadWaitRec * rec; (rec = m_waitList.Head()) != nil; ) {
|
|
|
|
m_waitList.Unlink(rec);
|
|
|
|
SetEvent(rec->event);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Decrement the owning object's reference count
|
|
|
|
object->DecRef();
|
|
|
|
|
|
|
|
s_critSect.Leave();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void CThreadDispRec::Complete (CCritSect * critSect) {
|
|
|
|
m_object->Complete(m_op, critSect, m_ioId);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void CThreadDispRec::LinkWait (ThreadWaitRec * wait) {
|
|
|
|
|
|
|
|
// The caller should have already claimed the critical section before
|
|
|
|
// calling this function
|
|
|
|
|
|
|
|
m_waitList.Link(wait);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* CThreadDispObject
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
CThreadDispObject::CThreadDispObject () {
|
|
|
|
IncRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void CThreadDispObject::Close () {
|
|
|
|
s_critSect.Enter();
|
|
|
|
DecRef();
|
|
|
|
s_critSect.Leave();
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
AsyncId CThreadDispObject::Queue (void * op) {
|
|
|
|
AsyncId asyncId = 0;
|
|
|
|
NEW(CThreadDispRec)(this, op, &asyncId);
|
|
|
|
SetEvent(s_signalEvent);
|
|
|
|
return asyncId;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Thread procedure
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
static unsigned CALLBACK W9xThreadProc (AsyncThread *) {
|
|
|
|
|
|
|
|
// Perform the main thread loop
|
|
|
|
for (;;) {
|
|
|
|
unsigned timeout = (unsigned)-1;
|
|
|
|
|
|
|
|
// If an operation is queued, complete it and dispatch a notification.
|
|
|
|
// The code that processes the operation is responsible for leaving
|
|
|
|
// our critical section. This ensures that operations are completed
|
|
|
|
// in order.
|
|
|
|
s_critSect.Enter();
|
|
|
|
CThreadDispRec * rec = s_dispList.Head();
|
|
|
|
if (rec) {
|
|
|
|
s_dispInProcList.Link(rec);
|
|
|
|
rec->Complete(&s_critSect);
|
|
|
|
DEL(rec);
|
|
|
|
timeout = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
s_critSect.Leave();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Consume events, check for destruction, and block if we have
|
|
|
|
// nothing to do.
|
|
|
|
HANDLE events[] = {s_destroyEvent, s_signalEvent};
|
|
|
|
dword result = WaitForMultipleObjects(
|
|
|
|
arrsize(events),
|
|
|
|
events,
|
|
|
|
FALSE,
|
|
|
|
INFINITE
|
|
|
|
);
|
|
|
|
if (result == WAIT_OBJECT_0)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Exported functions
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void W9xThreadDestroy (
|
|
|
|
unsigned exitThreadWaitMs
|
|
|
|
) {
|
|
|
|
|
|
|
|
// Wait until all outstanding I/O is complete. We allow new I/O
|
|
|
|
// operations to be queued while old ones are completing.
|
|
|
|
s_critSect.Enter();
|
|
|
|
while (s_dispList.Head() || s_dispInProcList.Head()) {
|
|
|
|
s_critSect.Leave();
|
|
|
|
Sleep(10);
|
|
|
|
s_critSect.Enter();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Once all I/O operations are complete, we disallow any future
|
|
|
|
// I/O operations from being queued.
|
|
|
|
s_destroying = true;
|
|
|
|
s_critSect.Leave();
|
|
|
|
|
|
|
|
// Signal thread destruction
|
|
|
|
if (s_destroyEvent)
|
|
|
|
SetEvent(s_destroyEvent);
|
|
|
|
|
|
|
|
// Wait for thread destruction
|
|
|
|
for (unsigned thread = kThreadCount; thread--; )
|
|
|
|
if (s_thread[thread]) {
|
|
|
|
|
|
|
|
// Wait for the thread to terminate
|
|
|
|
WaitForSingleObject(s_thread[thread], exitThreadWaitMs);
|
|
|
|
|
|
|
|
// Close the thread handle
|
|
|
|
CloseHandle(s_thread[thread]);
|
|
|
|
s_thread[thread] = 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// Destroy internal modules
|
|
|
|
W9xSocketDestroy();
|
|
|
|
|
|
|
|
// Destroy events
|
|
|
|
if (s_destroyEvent) {
|
|
|
|
CloseHandle(s_destroyEvent);
|
|
|
|
s_destroyEvent = 0;
|
|
|
|
}
|
|
|
|
if (s_shutdownEvent) {
|
|
|
|
CloseHandle(s_shutdownEvent);
|
|
|
|
s_shutdownEvent = 0;
|
|
|
|
}
|
|
|
|
if (s_signalEvent) {
|
|
|
|
CloseHandle(s_signalEvent);
|
|
|
|
s_signalEvent = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void W9xThreadInitialize () {
|
|
|
|
|
|
|
|
// Reset static variables
|
|
|
|
s_destroying = false;
|
|
|
|
|
|
|
|
// Create a manual reset event to use for signaling thread destruction
|
|
|
|
if (s_destroyEvent)
|
|
|
|
ResetEvent(s_destroyEvent);
|
|
|
|
else {
|
|
|
|
s_destroyEvent = CreateEvent(nil, TRUE, FALSE, nil);
|
|
|
|
ASSERT(s_destroyEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create an auto-reset event to use for signaling the thread to process
|
|
|
|
// notifications
|
|
|
|
if (!s_signalEvent) {
|
|
|
|
s_signalEvent = CreateEvent(nil, FALSE, FALSE, nil);
|
|
|
|
ASSERT(s_signalEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a manual reset event to use for signaling application shutdown
|
|
|
|
if (s_shutdownEvent)
|
|
|
|
ResetEvent(s_shutdownEvent);
|
|
|
|
else {
|
|
|
|
s_shutdownEvent = CreateEvent(nil, TRUE, FALSE, nil);
|
|
|
|
ASSERT(s_shutdownEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create threads
|
|
|
|
for (unsigned thread = 0; thread < kThreadCount; ++thread) {
|
|
|
|
if (!s_thread[thread]) {
|
|
|
|
s_thread[thread] = (HANDLE) AsyncThreadCreate(
|
|
|
|
W9xThreadProc,
|
|
|
|
(void *) thread,
|
|
|
|
L"W9xWorkerThread"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void W9xThreadSignalShutdown () {
|
|
|
|
SetEvent(s_shutdownEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void W9xThreadSleep (
|
|
|
|
unsigned sleepMs
|
|
|
|
) {
|
|
|
|
Sleep(sleepMs);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void W9xThreadWaitForShutdown () {
|
|
|
|
|
|
|
|
// We know that the applicaton is finished initializing at this point.
|
|
|
|
// While it was still initializing, it may have returned an infinite
|
|
|
|
// sleep time from the idle procedure, which would prevent us from ever
|
|
|
|
// calling it again. Therefore, we trigger an idle callback here.
|
|
|
|
SetEvent(s_signalEvent);
|
|
|
|
|
|
|
|
// Wait for the application to signal shutdown
|
|
|
|
WaitForSingleObject(s_shutdownEvent, INFINITE);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
bool W9xThreadWaitId (
|
|
|
|
AsyncFile file,
|
|
|
|
AsyncId asyncId,
|
|
|
|
unsigned timeoutMs
|
|
|
|
) {
|
|
|
|
// Find a pending I/O operation with the given id
|
|
|
|
s_critSect.Enter();
|
|
|
|
CThreadDispRec * disp;
|
|
|
|
for (disp = s_dispList.Head(); disp && (disp->GetId() != asyncId); disp = s_dispList.Next(disp))
|
|
|
|
;
|
|
|
|
if (!disp)
|
|
|
|
for (disp = s_dispInProcList.Head(); disp && (disp->GetId() != asyncId); disp = s_dispInProcList.Next(disp))
|
|
|
|
;
|
|
|
|
|
|
|
|
// If we couldn't find the given id, the operation must have already
|
|
|
|
// completed, so return true.
|
|
|
|
if (!disp) {
|
|
|
|
s_critSect.Leave();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The operation has not completed. If the timeout is zero, return
|
|
|
|
// false.
|
|
|
|
if (!timeoutMs) {
|
|
|
|
s_critSect.Leave();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a wait event
|
|
|
|
HANDLE event = CreateEvent(nil, FALSE, FALSE, nil);
|
|
|
|
|
|
|
|
// Create a wait record and link it to the I/O operation
|
|
|
|
ThreadWaitRec wait;
|
|
|
|
wait.event = event;
|
|
|
|
disp->LinkWait(&wait);
|
|
|
|
s_critSect.Leave();
|
|
|
|
|
|
|
|
// Wait for the operation to complete
|
|
|
|
DWORD result = WaitForSingleObject(event, timeoutMs);
|
|
|
|
|
|
|
|
// If the operation completed then the dispatcher unlinked our wait
|
|
|
|
// record before signaling it. We can simply free the event and return.
|
|
|
|
if (result == WAIT_OBJECT_0) {
|
|
|
|
CloseHandle(event);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Unlink our wait record from the I/O operation
|
|
|
|
s_critSect.Enter();
|
|
|
|
wait.link.Unlink();
|
|
|
|
s_critSect.Leave();
|
|
|
|
|
|
|
|
// Free the event
|
|
|
|
CloseHandle(event);
|
|
|
|
|
|
|
|
// Return false, because the operation did not complete during the
|
|
|
|
// timeout period
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace W9x
|