Myk
GitHub
commit
abfbfd5f70
@ -1,6 +0,0 @@
|
||||
project(dfhack-tinythread)
|
||||
add_library(dfhack-tinythread STATIC EXCLUDE_FROM_ALL tinythread.cpp tinythread.h)
|
||||
if(UNIX)
|
||||
target_link_libraries(dfhack-tinythread pthread)
|
||||
endif()
|
||||
ide_folder(dfhack-tinythread "Depends")
|
||||
@ -1,313 +0,0 @@
|
||||
/* -*- mode: c++; tab-width: 2; indent-tabs-mode: nil; -*-
|
||||
Copyright (c) 2010-2012 Marcus Geelnard
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include "tinythread.h"
|
||||
|
||||
#if defined(_TTHREAD_POSIX_)
|
||||
#include <unistd.h>
|
||||
#include <map>
|
||||
#elif defined(_TTHREAD_WIN32_)
|
||||
#include <process.h>
|
||||
#endif
|
||||
|
||||
|
||||
namespace tthread {
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// condition_variable
|
||||
//------------------------------------------------------------------------------
|
||||
// NOTE 1: The Win32 implementation of the condition_variable class is based on
|
||||
// the corresponding implementation in GLFW, which in turn is based on a
|
||||
// description by Douglas C. Schmidt and Irfan Pyarali:
|
||||
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
|
||||
//
|
||||
// NOTE 2: Windows Vista actually has native support for condition variables
|
||||
// (InitializeConditionVariable, WakeConditionVariable, etc), but we want to
|
||||
// be portable with pre-Vista Windows versions, so TinyThread++ does not use
|
||||
// Vista condition variables.
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
#define _CONDITION_EVENT_ONE 0
|
||||
#define _CONDITION_EVENT_ALL 1
|
||||
#endif
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
condition_variable::condition_variable() : mWaitersCount(0)
|
||||
{
|
||||
mEvents[_CONDITION_EVENT_ONE] = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||||
mEvents[_CONDITION_EVENT_ALL] = CreateEvent(NULL, TRUE, FALSE, NULL);
|
||||
InitializeCriticalSection(&mWaitersCountLock);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
condition_variable::~condition_variable()
|
||||
{
|
||||
CloseHandle(mEvents[_CONDITION_EVENT_ONE]);
|
||||
CloseHandle(mEvents[_CONDITION_EVENT_ALL]);
|
||||
DeleteCriticalSection(&mWaitersCountLock);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void condition_variable::_wait()
|
||||
{
|
||||
// Wait for either event to become signaled due to notify_one() or
|
||||
// notify_all() being called
|
||||
int result = WaitForMultipleObjects(2, mEvents, FALSE, INFINITE);
|
||||
|
||||
// Check if we are the last waiter
|
||||
EnterCriticalSection(&mWaitersCountLock);
|
||||
-- mWaitersCount;
|
||||
bool lastWaiter = (result == (WAIT_OBJECT_0 + _CONDITION_EVENT_ALL)) &&
|
||||
(mWaitersCount == 0);
|
||||
LeaveCriticalSection(&mWaitersCountLock);
|
||||
|
||||
// If we are the last waiter to be notified to stop waiting, reset the event
|
||||
if(lastWaiter)
|
||||
ResetEvent(mEvents[_CONDITION_EVENT_ALL]);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void condition_variable::notify_one()
|
||||
{
|
||||
// Are there any waiters?
|
||||
EnterCriticalSection(&mWaitersCountLock);
|
||||
bool haveWaiters = (mWaitersCount > 0);
|
||||
LeaveCriticalSection(&mWaitersCountLock);
|
||||
|
||||
// If we have any waiting threads, send them a signal
|
||||
if(haveWaiters)
|
||||
SetEvent(mEvents[_CONDITION_EVENT_ONE]);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void condition_variable::notify_all()
|
||||
{
|
||||
// Are there any waiters?
|
||||
EnterCriticalSection(&mWaitersCountLock);
|
||||
bool haveWaiters = (mWaitersCount > 0);
|
||||
LeaveCriticalSection(&mWaitersCountLock);
|
||||
|
||||
// If we have any waiting threads, send them a signal
|
||||
if(haveWaiters)
|
||||
SetEvent(mEvents[_CONDITION_EVENT_ALL]);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// POSIX pthread_t to unique thread::id mapping logic.
|
||||
// Note: Here we use a global thread safe std::map to convert instances of
|
||||
// pthread_t to small thread identifier numbers (unique within one process).
|
||||
// This method should be portable across different POSIX implementations.
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#if defined(_TTHREAD_POSIX_)
|
||||
static thread::id _pthread_t_to_ID(const pthread_t &aHandle)
|
||||
{
|
||||
static mutex idMapLock;
|
||||
static std::map<pthread_t, unsigned long int> idMap;
|
||||
static unsigned long int idCount(1);
|
||||
|
||||
lock_guard<mutex> guard(idMapLock);
|
||||
if(idMap.find(aHandle) == idMap.end())
|
||||
idMap[aHandle] = idCount ++;
|
||||
return thread::id(idMap[aHandle]);
|
||||
}
|
||||
#endif // _TTHREAD_POSIX_
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// thread
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/// Information to pass to the new thread (what to run).
|
||||
struct _thread_start_info {
|
||||
void (*mFunction)(void *); ///< Pointer to the function to be executed.
|
||||
void * mArg; ///< Function argument for the thread function.
|
||||
thread * mThread; ///< Pointer to the thread object.
|
||||
};
|
||||
|
||||
// Thread wrapper function.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
unsigned WINAPI thread::wrapper_function(void * aArg)
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
void * thread::wrapper_function(void * aArg)
|
||||
#endif
|
||||
{
|
||||
// Get thread startup information
|
||||
_thread_start_info * ti = (_thread_start_info *) aArg;
|
||||
|
||||
try
|
||||
{
|
||||
// Call the actual client thread function
|
||||
ti->mFunction(ti->mArg);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
// Uncaught exceptions will terminate the application (default behavior
|
||||
// according to C++11)
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
#if 0
|
||||
// DFHack fix: this code prevents join from freeing thread resources.
|
||||
|
||||
// The thread is no longer executing
|
||||
lock_guard<mutex> guard(ti->mThread->mDataMutex);
|
||||
ti->mThread->mNotAThread = true;
|
||||
#endif
|
||||
|
||||
// The thread is responsible for freeing the startup information
|
||||
delete ti;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
thread::thread(void (*aFunction)(void *), void * aArg)
|
||||
{
|
||||
// Serialize access to this thread structure
|
||||
lock_guard<mutex> guard(mDataMutex);
|
||||
|
||||
// Fill out the thread startup information (passed to the thread wrapper,
|
||||
// which will eventually free it)
|
||||
_thread_start_info * ti = new _thread_start_info;
|
||||
ti->mFunction = aFunction;
|
||||
ti->mArg = aArg;
|
||||
ti->mThread = this;
|
||||
|
||||
// The thread is now alive
|
||||
mNotAThread = false;
|
||||
|
||||
// Create the thread
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
mHandle = (HANDLE) _beginthreadex(0, 0, wrapper_function, (void *) ti, 0, &mWin32ThreadID);
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
if(pthread_create(&mHandle, NULL, wrapper_function, (void *) ti) != 0)
|
||||
mHandle = 0;
|
||||
#endif
|
||||
|
||||
// Did we fail to create the thread?
|
||||
if(!mHandle)
|
||||
{
|
||||
mNotAThread = true;
|
||||
delete ti;
|
||||
}
|
||||
}
|
||||
|
||||
thread::~thread()
|
||||
{
|
||||
if(joinable())
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
void thread::join()
|
||||
{
|
||||
if(joinable())
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
WaitForSingleObject(mHandle, INFINITE);
|
||||
CloseHandle(mHandle);
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
pthread_join(mHandle, NULL);
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
// DFHack patch: moved here from the wrapper function
|
||||
lock_guard<mutex> guard(mDataMutex);
|
||||
mNotAThread = true;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
bool thread::joinable() const
|
||||
{
|
||||
mDataMutex.lock();
|
||||
bool result = !mNotAThread;
|
||||
mDataMutex.unlock();
|
||||
return result;
|
||||
}
|
||||
|
||||
void thread::detach()
|
||||
{
|
||||
mDataMutex.lock();
|
||||
if(!mNotAThread)
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
CloseHandle(mHandle);
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
pthread_detach(mHandle);
|
||||
#endif
|
||||
mNotAThread = true;
|
||||
}
|
||||
mDataMutex.unlock();
|
||||
}
|
||||
|
||||
thread::id thread::get_id() const
|
||||
{
|
||||
if(!joinable())
|
||||
return id();
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
return id((unsigned long int) mWin32ThreadID);
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
return _pthread_t_to_ID(mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
unsigned thread::hardware_concurrency()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
SYSTEM_INFO si;
|
||||
GetSystemInfo(&si);
|
||||
return (int) si.dwNumberOfProcessors;
|
||||
#elif defined(_SC_NPROCESSORS_ONLN)
|
||||
return (int) sysconf(_SC_NPROCESSORS_ONLN);
|
||||
#elif defined(_SC_NPROC_ONLN)
|
||||
return (int) sysconf(_SC_NPROC_ONLN);
|
||||
#else
|
||||
// The standard requires this function to return zero if the number of
|
||||
// hardware cores could not be determined.
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// this_thread
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
thread::id this_thread::get_id()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
return thread::id((unsigned long int) GetCurrentThreadId());
|
||||
#elif defined(_TTHREAD_POSIX_)
|
||||
return _pthread_t_to_ID(pthread_self());
|
||||
#endif
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,714 +0,0 @@
|
||||
/* -*- mode: c++; tab-width: 2; indent-tabs-mode: nil; -*-
|
||||
Copyright (c) 2010-2012 Marcus Geelnard
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#ifndef _TINYTHREAD_H_
|
||||
#define _TINYTHREAD_H_
|
||||
|
||||
/// @file
|
||||
/// @mainpage TinyThread++ API Reference
|
||||
///
|
||||
/// @section intro_sec Introduction
|
||||
/// TinyThread++ is a minimal, portable implementation of basic threading
|
||||
/// classes for C++.
|
||||
///
|
||||
/// They closely mimic the functionality and naming of the C++11 standard, and
|
||||
/// should be easily replaceable with the corresponding std:: variants.
|
||||
///
|
||||
/// @section port_sec Portability
|
||||
/// The Win32 variant uses the native Win32 API for implementing the thread
|
||||
/// classes, while for other systems, the POSIX threads API (pthread) is used.
|
||||
///
|
||||
/// @section class_sec Classes
|
||||
/// In order to mimic the threading API of the C++11 standard, subsets of
|
||||
/// several classes are provided. The fundamental classes are:
|
||||
/// @li tthread::thread
|
||||
/// @li tthread::mutex
|
||||
/// @li tthread::recursive_mutex
|
||||
/// @li tthread::condition_variable
|
||||
/// @li tthread::lock_guard
|
||||
///
|
||||
/// @section misc_sec Miscellaneous
|
||||
/// The following special keywords are available: #thread_local.
|
||||
///
|
||||
/// For more detailed information (including additional classes), browse the
|
||||
/// different sections of this documentation. A good place to start is:
|
||||
/// tinythread.h.
|
||||
|
||||
// Which platform are we on?
|
||||
#if !defined(_TTHREAD_PLATFORM_DEFINED_)
|
||||
#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)
|
||||
#define _TTHREAD_WIN32_
|
||||
#else
|
||||
#define _TTHREAD_POSIX_
|
||||
#endif
|
||||
#define _TTHREAD_PLATFORM_DEFINED_
|
||||
#endif
|
||||
|
||||
// Platform specific includes
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
#define NOMINMAX
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#define __UNDEF_LEAN_AND_MEAN
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#ifdef __UNDEF_LEAN_AND_MEAN
|
||||
#undef WIN32_LEAN_AND_MEAN
|
||||
#undef __UNDEF_LEAN_AND_MEAN
|
||||
#endif
|
||||
#else
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <sched.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
// Generic includes
|
||||
#include <ostream>
|
||||
|
||||
/// TinyThread++ version (major number).
|
||||
#define TINYTHREAD_VERSION_MAJOR 1
|
||||
/// TinyThread++ version (minor number).
|
||||
#define TINYTHREAD_VERSION_MINOR 1
|
||||
/// TinyThread++ version (full version).
|
||||
#define TINYTHREAD_VERSION (TINYTHREAD_VERSION_MAJOR * 100 + TINYTHREAD_VERSION_MINOR)
|
||||
|
||||
// Do we have a fully featured C++11 compiler?
|
||||
#if (__cplusplus > 199711L) || (defined(__STDCXX_VERSION__) && (__STDCXX_VERSION__ >= 201001L))
|
||||
#define _TTHREAD_CPP11_
|
||||
#endif
|
||||
|
||||
// ...at least partial C++11?
|
||||
#if defined(_TTHREAD_CPP11_) || defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(__GXX_EXPERIMENTAL_CPP0X__)
|
||||
#define _TTHREAD_CPP11_PARTIAL_
|
||||
#endif
|
||||
|
||||
// Macro for disabling assignments of objects.
|
||||
#ifdef _TTHREAD_CPP11_PARTIAL_
|
||||
#define _TTHREAD_DISABLE_ASSIGNMENT(name) \
|
||||
name(const name&) = delete; \
|
||||
name& operator=(const name&) = delete;
|
||||
#else
|
||||
#define _TTHREAD_DISABLE_ASSIGNMENT(name) \
|
||||
name(const name&); \
|
||||
name& operator=(const name&);
|
||||
#endif
|
||||
|
||||
/// @def thread_local
|
||||
/// Thread local storage keyword.
|
||||
/// A variable that is declared with the @c thread_local keyword makes the
|
||||
/// value of the variable local to each thread (known as thread-local storage,
|
||||
/// or TLS). Example usage:
|
||||
/// @code
|
||||
/// // This variable is local to each thread.
|
||||
/// thread_local int variable;
|
||||
/// @endcode
|
||||
/// @note The @c thread_local keyword is a macro that maps to the corresponding
|
||||
/// compiler directive (e.g. @c __declspec(thread)). While the C++11 standard
|
||||
/// allows for non-trivial types (e.g. classes with constructors and
|
||||
/// destructors) to be declared with the @c thread_local keyword, most pre-C++11
|
||||
/// compilers only allow for trivial types (e.g. @c int). So, to guarantee
|
||||
/// portable code, only use trivial types for thread local storage.
|
||||
/// @note This directive is currently not supported on Mac OS X (it will give
|
||||
/// a compiler error), since compile-time TLS is not supported in the Mac OS X
|
||||
/// executable format. Also, some older versions of MinGW (before GCC 4.x) do
|
||||
/// not support this directive.
|
||||
/// @hideinitializer
|
||||
|
||||
#if !defined(_TTHREAD_CPP11_) && !defined(thread_local)
|
||||
#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
|
||||
#define thread_local __thread
|
||||
#else
|
||||
#define thread_local __declspec(thread)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/// Main name space for TinyThread++.
|
||||
/// This namespace is more or less equivalent to the @c std namespace for the
|
||||
/// C++11 thread classes. For instance, the tthread::mutex class corresponds to
|
||||
/// the std::mutex class.
|
||||
namespace tthread {
|
||||
|
||||
/// Mutex class.
|
||||
/// This is a mutual exclusion object for synchronizing access to shared
|
||||
/// memory areas for several threads. The mutex is non-recursive (i.e. a
|
||||
/// program may deadlock if the thread that owns a mutex object calls lock()
|
||||
/// on that object).
|
||||
/// @see recursive_mutex
|
||||
class mutex {
|
||||
public:
|
||||
/// Constructor.
|
||||
mutex()
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
: mAlreadyLocked(false)
|
||||
#endif
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
InitializeCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_init(&mHandle, NULL);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Destructor.
|
||||
~mutex()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
DeleteCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_destroy(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Lock the mutex.
|
||||
/// The method will block the calling thread until a lock on the mutex can
|
||||
/// be obtained. The mutex remains locked until @c unlock() is called.
|
||||
/// @see lock_guard
|
||||
inline void lock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
EnterCriticalSection(&mHandle);
|
||||
while(mAlreadyLocked) Sleep(1000); // Simulate deadlock...
|
||||
mAlreadyLocked = true;
|
||||
#else
|
||||
pthread_mutex_lock(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Try to lock the mutex.
|
||||
/// The method will try to lock the mutex. If it fails, the function will
|
||||
/// return immediately (non-blocking).
|
||||
/// @return @c true if the lock was acquired, or @c false if the lock could
|
||||
/// not be acquired.
|
||||
inline bool try_lock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
bool ret = (TryEnterCriticalSection(&mHandle) ? true : false);
|
||||
if(ret && mAlreadyLocked)
|
||||
{
|
||||
LeaveCriticalSection(&mHandle);
|
||||
ret = false;
|
||||
}
|
||||
return ret;
|
||||
#else
|
||||
return (pthread_mutex_trylock(&mHandle) == 0) ? true : false;
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Unlock the mutex.
|
||||
/// If any threads are waiting for the lock on this mutex, one of them will
|
||||
/// be unblocked.
|
||||
inline void unlock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
mAlreadyLocked = false;
|
||||
LeaveCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_unlock(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
_TTHREAD_DISABLE_ASSIGNMENT(mutex)
|
||||
|
||||
private:
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
CRITICAL_SECTION mHandle;
|
||||
bool mAlreadyLocked;
|
||||
#else
|
||||
pthread_mutex_t mHandle;
|
||||
#endif
|
||||
|
||||
friend class condition_variable;
|
||||
};
|
||||
|
||||
/// Recursive mutex class.
|
||||
/// This is a mutual exclusion object for synchronizing access to shared
|
||||
/// memory areas for several threads. The mutex is recursive (i.e. a thread
|
||||
/// may lock the mutex several times, as long as it unlocks the mutex the same
|
||||
/// number of times).
|
||||
/// @see mutex
|
||||
class recursive_mutex {
|
||||
public:
|
||||
/// Constructor.
|
||||
recursive_mutex()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
InitializeCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutexattr_t attr;
|
||||
pthread_mutexattr_init(&attr);
|
||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||
pthread_mutex_init(&mHandle, &attr);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Destructor.
|
||||
~recursive_mutex()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
DeleteCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_destroy(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Lock the mutex.
|
||||
/// The method will block the calling thread until a lock on the mutex can
|
||||
/// be obtained. The mutex remains locked until @c unlock() is called.
|
||||
/// @see lock_guard
|
||||
inline void lock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
EnterCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_lock(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Try to lock the mutex.
|
||||
/// The method will try to lock the mutex. If it fails, the function will
|
||||
/// return immediately (non-blocking).
|
||||
/// @return @c true if the lock was acquired, or @c false if the lock could
|
||||
/// not be acquired.
|
||||
inline bool try_lock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
return TryEnterCriticalSection(&mHandle) ? true : false;
|
||||
#else
|
||||
return (pthread_mutex_trylock(&mHandle) == 0) ? true : false;
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Unlock the mutex.
|
||||
/// If any threads are waiting for the lock on this mutex, one of them will
|
||||
/// be unblocked.
|
||||
inline void unlock()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
LeaveCriticalSection(&mHandle);
|
||||
#else
|
||||
pthread_mutex_unlock(&mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
_TTHREAD_DISABLE_ASSIGNMENT(recursive_mutex)
|
||||
|
||||
private:
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
CRITICAL_SECTION mHandle;
|
||||
#else
|
||||
pthread_mutex_t mHandle;
|
||||
#endif
|
||||
|
||||
friend class condition_variable;
|
||||
};
|
||||
|
||||
/// Lock guard class.
|
||||
/// The constructor locks the mutex, and the destructor unlocks the mutex, so
|
||||
/// the mutex will automatically be unlocked when the lock guard goes out of
|
||||
/// scope. Example usage:
|
||||
/// @code
|
||||
/// mutex m;
|
||||
/// int counter;
|
||||
///
|
||||
/// void increment()
|
||||
/// {
|
||||
/// lock_guard<mutex> guard(m);
|
||||
/// ++ counter;
|
||||
/// }
|
||||
/// @endcode
|
||||
|
||||
template <class T>
|
||||
class lock_guard {
|
||||
public:
|
||||
typedef T mutex_type;
|
||||
|
||||
lock_guard() : mMutex(0) {}
|
||||
|
||||
/// The constructor locks the mutex.
|
||||
explicit lock_guard(mutex_type &aMutex)
|
||||
{
|
||||
mMutex = &aMutex;
|
||||
mMutex->lock();
|
||||
}
|
||||
|
||||
/// The destructor unlocks the mutex.
|
||||
~lock_guard()
|
||||
{
|
||||
if(mMutex)
|
||||
mMutex->unlock();
|
||||
}
|
||||
|
||||
private:
|
||||
mutex_type * mMutex;
|
||||
};
|
||||
|
||||
/// Condition variable class.
|
||||
/// This is a signalling object for synchronizing the execution flow for
|
||||
/// several threads. Example usage:
|
||||
/// @code
|
||||
/// // Shared data and associated mutex and condition variable objects
|
||||
/// int count;
|
||||
/// mutex m;
|
||||
/// condition_variable cond;
|
||||
///
|
||||
/// // Wait for the counter to reach a certain number
|
||||
/// void wait_counter(int targetCount)
|
||||
/// {
|
||||
/// lock_guard<mutex> guard(m);
|
||||
/// while(count < targetCount)
|
||||
/// cond.wait(m);
|
||||
/// }
|
||||
///
|
||||
/// // Increment the counter, and notify waiting threads
|
||||
/// void increment()
|
||||
/// {
|
||||
/// lock_guard<mutex> guard(m);
|
||||
/// ++ count;
|
||||
/// cond.notify_all();
|
||||
/// }
|
||||
/// @endcode
|
||||
class condition_variable {
|
||||
public:
|
||||
/// Constructor.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
condition_variable();
|
||||
#else
|
||||
condition_variable()
|
||||
{
|
||||
pthread_cond_init(&mHandle, NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Destructor.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
~condition_variable();
|
||||
#else
|
||||
~condition_variable()
|
||||
{
|
||||
pthread_cond_destroy(&mHandle);
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Wait for the condition.
|
||||
/// The function will block the calling thread until the condition variable
|
||||
/// is woken by @c notify_one(), @c notify_all() or a spurious wake up.
|
||||
/// @param[in] aMutex A mutex that will be unlocked when the wait operation
|
||||
/// starts, an locked again as soon as the wait operation is finished.
|
||||
template <class _mutexT>
|
||||
inline void wait(_mutexT &aMutex)
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
// Increment number of waiters
|
||||
EnterCriticalSection(&mWaitersCountLock);
|
||||
++ mWaitersCount;
|
||||
LeaveCriticalSection(&mWaitersCountLock);
|
||||
|
||||
// Release the mutex while waiting for the condition (will decrease
|
||||
// the number of waiters when done)...
|
||||
aMutex.unlock();
|
||||
_wait();
|
||||
aMutex.lock();
|
||||
#else
|
||||
pthread_cond_wait(&mHandle, &aMutex.mHandle);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Notify one thread that is waiting for the condition.
|
||||
/// If at least one thread is blocked waiting for this condition variable,
|
||||
/// one will be woken up.
|
||||
/// @note Only threads that started waiting prior to this call will be
|
||||
/// woken up.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void notify_one();
|
||||
#else
|
||||
inline void notify_one()
|
||||
{
|
||||
pthread_cond_signal(&mHandle);
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Notify all threads that are waiting for the condition.
|
||||
/// All threads that are blocked waiting for this condition variable will
|
||||
/// be woken up.
|
||||
/// @note Only threads that started waiting prior to this call will be
|
||||
/// woken up.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void notify_all();
|
||||
#else
|
||||
inline void notify_all()
|
||||
{
|
||||
pthread_cond_broadcast(&mHandle);
|
||||
}
|
||||
#endif
|
||||
|
||||
_TTHREAD_DISABLE_ASSIGNMENT(condition_variable)
|
||||
|
||||
private:
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
void _wait();
|
||||
HANDLE mEvents[2]; ///< Signal and broadcast event HANDLEs.
|
||||
unsigned int mWaitersCount; ///< Count of the number of waiters.
|
||||
CRITICAL_SECTION mWaitersCountLock; ///< Serialize access to mWaitersCount.
|
||||
#else
|
||||
pthread_cond_t mHandle;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
/// Thread class.
|
||||
class thread {
|
||||
public:
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
typedef HANDLE native_handle_type;
|
||||
#else
|
||||
typedef pthread_t native_handle_type;
|
||||
#endif
|
||||
|
||||
class id;
|
||||
|
||||
/// Default constructor.
|
||||
/// Construct a @c thread object without an associated thread of execution
|
||||
/// (i.e. non-joinable).
|
||||
thread() : mHandle(0), mNotAThread(true)
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
, mWin32ThreadID(0)
|
||||
#endif
|
||||
{}
|
||||
|
||||
/// Thread starting constructor.
|
||||
/// Construct a @c thread object with a new thread of execution.
|
||||
/// @param[in] aFunction A function pointer to a function of type:
|
||||
/// <tt>void fun(void * arg)</tt>
|
||||
/// @param[in] aArg Argument to the thread function.
|
||||
/// @note This constructor is not fully compatible with the standard C++
|
||||
/// thread class. It is more similar to the pthread_create() (POSIX) and
|
||||
/// CreateThread() (Windows) functions.
|
||||
thread(void (*aFunction)(void *), void * aArg);
|
||||
|
||||
/// Destructor.
|
||||
/// @note If the thread is joinable upon destruction, @c std::terminate()
|
||||
/// will be called, which terminates the process. It is always wise to do
|
||||
/// @c join() before deleting a thread object.
|
||||
~thread();
|
||||
|
||||
/// Wait for the thread to finish (join execution flows).
|
||||
/// After calling @c join(), the thread object is no longer associated with
|
||||
/// a thread of execution (i.e. it is not joinable, and you may not join
|
||||
/// with it nor detach from it).
|
||||
void join();
|
||||
|
||||
/// Check if the thread is joinable.
|
||||
/// A thread object is joinable if it has an associated thread of execution.
|
||||
bool joinable() const;
|
||||
|
||||
/// Detach from the thread.
|
||||
/// After calling @c detach(), the thread object is no longer assicated with
|
||||
/// a thread of execution (i.e. it is not joinable). The thread continues
|
||||
/// execution without the calling thread blocking, and when the thread
|
||||
/// ends execution, any owned resources are released.
|
||||
void detach();
|
||||
|
||||
/// Return the thread ID of a thread object.
|
||||
id get_id() const;
|
||||
|
||||
/// Get the native handle for this thread.
|
||||
/// @note Under Windows, this is a @c HANDLE, and under POSIX systems, this
|
||||
/// is a @c pthread_t.
|
||||
inline native_handle_type native_handle()
|
||||
{
|
||||
return mHandle;
|
||||
}
|
||||
|
||||
/// Determine the number of threads which can possibly execute concurrently.
|
||||
/// This function is useful for determining the optimal number of threads to
|
||||
/// use for a task.
|
||||
/// @return The number of hardware thread contexts in the system.
|
||||
/// @note If this value is not defined, the function returns zero (0).
|
||||
static unsigned hardware_concurrency();
|
||||
|
||||
_TTHREAD_DISABLE_ASSIGNMENT(thread)
|
||||
|
||||
private:
|
||||
native_handle_type mHandle; ///< Thread handle.
|
||||
mutable mutex mDataMutex; ///< Serializer for access to the thread private data.
|
||||
bool mNotAThread; ///< True if this object is not a thread of execution.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
unsigned int mWin32ThreadID; ///< Unique thread ID (filled out by _beginthreadex).
|
||||
#endif
|
||||
|
||||
// This is the internal thread wrapper function.
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
static unsigned WINAPI wrapper_function(void * aArg);
|
||||
#else
|
||||
static void * wrapper_function(void * aArg);
|
||||
#endif
|
||||
};
|
||||
|
||||
/// Thread ID.
|
||||
/// The thread ID is a unique identifier for each thread.
|
||||
/// @see thread::get_id()
|
||||
class thread::id {
|
||||
public:
|
||||
/// Default constructor.
|
||||
/// The default constructed ID is that of thread without a thread of
|
||||
/// execution.
|
||||
id() : mId(0) {};
|
||||
|
||||
id(unsigned long int aId) : mId(aId) {};
|
||||
|
||||
id(const id& aId) : mId(aId.mId) {};
|
||||
|
||||
inline id & operator=(const id &aId)
|
||||
{
|
||||
mId = aId.mId;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline friend bool operator==(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId == aId2.mId);
|
||||
}
|
||||
|
||||
inline friend bool operator!=(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId != aId2.mId);
|
||||
}
|
||||
|
||||
inline friend bool operator<=(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId <= aId2.mId);
|
||||
}
|
||||
|
||||
inline friend bool operator<(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId < aId2.mId);
|
||||
}
|
||||
|
||||
inline friend bool operator>=(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId >= aId2.mId);
|
||||
}
|
||||
|
||||
inline friend bool operator>(const id &aId1, const id &aId2)
|
||||
{
|
||||
return (aId1.mId > aId2.mId);
|
||||
}
|
||||
|
||||
inline friend std::ostream& operator <<(std::ostream &os, const id &obj)
|
||||
{
|
||||
os << obj.mId;
|
||||
return os;
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned long int mId;
|
||||
};
|
||||
|
||||
|
||||
// Related to <ratio> - minimal to be able to support chrono.
|
||||
typedef long long __intmax_t;
|
||||
|
||||
/// Minimal implementation of the @c ratio class. This class provides enough
|
||||
/// functionality to implement some basic @c chrono classes.
|
||||
template <__intmax_t N, __intmax_t D = 1> class ratio {
|
||||
public:
|
||||
static double _as_double() { return double(N) / double(D); }
|
||||
};
|
||||
|
||||
/// Minimal implementation of the @c chrono namespace.
|
||||
/// The @c chrono namespace provides types for specifying time intervals.
|
||||
namespace chrono {
|
||||
/// Duration template class. This class provides enough functionality to
|
||||
/// implement @c this_thread::sleep_for().
|
||||
template <class _Rep, class _Period = ratio<1> > class duration {
|
||||
private:
|
||||
_Rep rep_;
|
||||
public:
|
||||
typedef _Rep rep;
|
||||
typedef _Period period;
|
||||
|
||||
/// Construct a duration object with the given duration.
|
||||
template <class _Rep2>
|
||||
explicit duration(const _Rep2& r) : rep_(r) {};
|
||||
|
||||
/// Return the value of the duration object.
|
||||
rep count() const
|
||||
{
|
||||
return rep_;
|
||||
}
|
||||
};
|
||||
|
||||
// Standard duration types.
|
||||
typedef duration<__intmax_t, ratio<1, 1000000000> > nanoseconds; ///< Duration with the unit nanoseconds.
|
||||
typedef duration<__intmax_t, ratio<1, 1000000> > microseconds; ///< Duration with the unit microseconds.
|
||||
typedef duration<__intmax_t, ratio<1, 1000> > milliseconds; ///< Duration with the unit milliseconds.
|
||||
typedef duration<__intmax_t> seconds; ///< Duration with the unit seconds.
|
||||
typedef duration<__intmax_t, ratio<60> > minutes; ///< Duration with the unit minutes.
|
||||
typedef duration<__intmax_t, ratio<3600> > hours; ///< Duration with the unit hours.
|
||||
}
|
||||
|
||||
/// The namespace @c this_thread provides methods for dealing with the
|
||||
/// calling thread.
|
||||
namespace this_thread {
|
||||
/// Return the thread ID of the calling thread.
|
||||
thread::id get_id();
|
||||
|
||||
/// Yield execution to another thread.
|
||||
/// Offers the operating system the opportunity to schedule another thread
|
||||
/// that is ready to run on the current processor.
|
||||
inline void yield()
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
Sleep(0);
|
||||
#else
|
||||
sched_yield();
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Blocks the calling thread for a period of time.
|
||||
/// @param[in] aTime Minimum time to put the thread to sleep.
|
||||
/// Example usage:
|
||||
/// @code
|
||||
/// // Sleep for 100 milliseconds
|
||||
/// this_thread::sleep_for(chrono::milliseconds(100));
|
||||
/// @endcode
|
||||
/// @note Supported duration types are: nanoseconds, microseconds,
|
||||
/// milliseconds, seconds, minutes and hours.
|
||||
template <class _Rep, class _Period> void sleep_for(const chrono::duration<_Rep, _Period>& aTime)
|
||||
{
|
||||
#if defined(_TTHREAD_WIN32_)
|
||||
Sleep(int(double(aTime.count()) * (1000.0 * _Period::_as_double()) + 0.5));
|
||||
#else
|
||||
usleep(int(double(aTime.count()) * (1000000.0 * _Period::_as_double()) + 0.5));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Define/macro cleanup
|
||||
#undef _TTHREAD_DISABLE_ASSIGNMENT
|
||||
|
||||
#endif // _TINYTHREAD_H_
|
||||
Loading…
Reference in New Issue