CWE-ou-minkata/Sources/Plasma/CoreLib/hsThread_Win.cpp

/*==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/>.

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==*/

#include <process.h>

#include "hsThread.h"
#include "hsExceptions.h"
#include "hsMemory.h"

// typedef unsigned int __stdcall (*EntryPtCB)(void*);

static DWORD __stdcall gEntryPoint(void* param)
{
	return ((hsThread*)param)->WinRun();
}

static unsigned int __stdcall gEntryPointBT(void* param)
{
	return ((hsThread*)param)->WinRun();
}

hsThread::hsThread(UInt32 stackSize) : fStackSize(stackSize), fQuit(false), fThreadH(nil), fQuitSemaH(nil)
{
}

hsThread::~hsThread()
{
	this->Stop();
}

void hsThread::Start()
{
	if (fThreadH == nil)
	{
		fQuitSemaH = ::CreateSemaphore(nil, 0, kPosInfinity32, nil);
		if (fQuitSemaH == nil)
			throw hsOSException(-1);

#if 0
		fThreadH = ::CreateThread(nil, fStackSize, gEntryPoint, this, 0, &fThreadId);
#else
		fThreadH = (HANDLE)_beginthreadex(nil, fStackSize, gEntryPointBT, this, 0, (unsigned int*)&fThreadId);
#endif
		if (fThreadH == nil)
			throw hsOSException(-1);
	}
}

void hsThread::Stop()
{
	if (fThreadH != nil)
	{	this->fQuit = true;

		if (fQuitSemaH != nil)
			::WaitForSingleObject(fQuitSemaH, INFINITE);	// wait for the thread to quit

		::CloseHandle(fThreadH);
		fThreadH = nil;
		::CloseHandle(fQuitSemaH);
		fQuitSemaH = nil;
	}
}

DWORD hsThread::WinRun()
{
	DWORD	result = this->Run();

	::ReleaseSemaphore(fQuitSemaH, 1, nil);	// signal that we've quit

	return result;
}

/////////////////////////////////////////////////////////////////////////////////////////

void* hsThread::Alloc(size_t size)
{
	return HSMemory::New(size);
}

void hsThread::Free(void* p)
{
	HSMemory::Delete(p);
}

void hsThread::ThreadYield()
{
	//	Don't know how to explicitly yield on WIN32
}

//////////////////////////////////////////////////////////////////////////////

hsMutex::hsMutex()
{
	fMutexH = ::CreateMutex(nil, false, nil);
	if (fMutexH == nil)
		throw hsOSException(-1);
}

hsMutex::~hsMutex()
{
	::CloseHandle(fMutexH);
}

void hsMutex::Lock()
{
	DWORD state = ::WaitForSingleObject(fMutexH, INFINITE);
	hsAssert(state != WAIT_FAILED,"hsMutex::Lock -> Wait Failed");
	hsAssert(state != WAIT_ABANDONED,"hsMutex::Lock -> Abandoned Mutex");
	hsAssert(state != WAIT_TIMEOUT,"hsMutex::Lock -> Infinite Timeout expired?");
}

hsBool hsMutex::TryLock()
{
	DWORD state = ::WaitForSingleObject(fMutexH, 0);
	hsAssert(state != WAIT_ABANDONED,"hsMutex::TryLock -> Abandoned Mutex");
	return state == WAIT_OBJECT_0?true:false;
}

void hsMutex::Unlock()
{
	BOOL result = ::ReleaseMutex(fMutexH);
	hsAssert(result != 0, "hsMutex::Unlock Failed!");

}

//////////////////////////////////////////////////////////////////////////////

hsSemaphore::hsSemaphore(int initialValue, const char *name)
{
	fSemaH = ::CreateSemaphore(nil, initialValue, kPosInfinity32, name);
	if (fSemaH == nil)
		throw hsOSException(-1);
}

hsSemaphore::~hsSemaphore()
{
	::CloseHandle(fSemaH);
}

hsBool hsSemaphore::Wait(hsMilliseconds timeToWait)
{
	if (timeToWait == kPosInfinity32)
		timeToWait = INFINITE;
	
	DWORD result =::WaitForSingleObject(fSemaH, timeToWait);

	if (result == WAIT_OBJECT_0)
		return true;
	else
	{	hsThrowIfFalse(result == WAIT_TIMEOUT);
		return false;
	}
}

void hsSemaphore::Signal()
{
	::ReleaseSemaphore(fSemaH, 1, nil);
}

///////////////////////////////////////////////////////////////

hsEvent::hsEvent()
{
	fEvent = ::CreateEvent(nil,true,false,nil);
	if (fEvent == nil)
		throw hsOSException(-1);
}

hsEvent::~hsEvent()
{
	::CloseHandle(fEvent);
}

hsBool hsEvent::Wait(hsMilliseconds timeToWait)
{
	if (timeToWait == kPosInfinity32)
		timeToWait = INFINITE;
	
	DWORD result =::WaitForSingleObject(fEvent, timeToWait);

	if (result == WAIT_OBJECT_0)
	{
		::ResetEvent(fEvent);
		return true;
	}
	else
	{	hsThrowIfFalse(result == WAIT_TIMEOUT);
		return false;
	}
}

void hsEvent::Signal()
{
	::SetEvent(fEvent);
}