diff -r 000000000000 -r ba3d4abaf3f1 include/am-thread-windows.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/include/am-thread-windows.h Fri Aug 23 20:34:17 2013 -0700 @@ -0,0 +1,161 @@ +// vim: set sts=8 ts=2 sw=2 tw=99 et: +// +// Copyright (C) 2013, David Anderson and AlliedModders LLC +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of AlliedModders LLC nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#ifndef _include_amtl_thread_windows_h_ +#define _include_amtl_thread_windows_h_ + +#include + +namespace ke { + +class CriticalSection : public Lockable +{ + public: + CriticalSection() { + InitializeCriticalSection(&cs_); + } + ~CriticalSection() { + DeleteCriticalSection(&cs_); + } + + bool DoTryLock() KE_OVERRIDE { + return !!TryEnterCriticalSection(&cs_); + } + void DoLock() KE_OVERRIDE { + EnterCriticalSection(&cs_); + } + + void DoUnlock() KE_OVERRIDE { + LeaveCriticalSection(&cs_); + } + + private: + CRITICAL_SECTION cs_; +}; + +typedef CriticalSection Mutex; + +// Currently, this class only supports single-listener CVs. +class ConditionVariable : public Lockable +{ + public: + ConditionVariable() { + event_ = CreateEvent(NULL, FALSE, FALSE, NULL); + } + ~ConditionVariable() { + CloseHandle(event_); + } + + bool DoTryLock() KE_OVERRIDE { + return cs_.DoTryLock(); + } + void DoLock() KE_OVERRIDE { + cs_.DoLock(); + } + void DoUnlock() KE_OVERRIDE { + cs_.DoUnlock(); + } + + void Notify() { + AssertCurrentThreadOwns(); + SetEvent(event_); + } + + WaitResult Wait(size_t timeout_ms) { + // This will assert if the lock has not been acquired. We don't need to be + // atomic here, like pthread_cond_wait, because the event bit will stick + // until reset by a wait function. + Unlock(); + DWORD rv = WaitForSingleObject(event_, timeout_ms); + Lock(); + + if (rv == WAIT_TIMEOUT) + return Wait_Timeout; + if (rv == WAIT_FAILED) + return Wait_Error; + return Wait_Signaled; + } + + WaitResult Wait() { + return Wait(INFINITE); + } + + private: + CriticalSection cs_; + HANDLE event_; +}; + +class Thread +{ + public: + Thread(IRunnable *run, const char *name = NULL) { + thread_ = CreateThread(NULL, 0, Main, run, 0, NULL); + } + ~Thread() { + if (!thread_) + return; + CloseHandle(thread_); + } + + bool Succeeded() const { + return !!thread_; + } + + void Join() { + if (!Succeeded()) + return; + WaitForSingleObject(thread_, INFINITE); + } + + HANDLE handle() const { + return thread_; + } + + private: + static DWORD WINAPI Main(LPVOID arg) { + ((IRunnable *)arg)->Run(); + return 0; + } + +#pragma pack(push, 8) + struct ThreadNameInfo { + DWORD dwType; + LPCSTR szName; + DWORD dwThreadID; + DWORD dwFlags; + }; +#pragma pack(pop) + + private: + HANDLE thread_; +}; + +} // namespace ke + +#endif // _include_amtl_thread_windows_h_