X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Fos_thread.hpp;h=9dc656eedce84798480de480b3fa1747e1da7c9b;hb=5b827e13413d9790981601522eb9fe5070e5615e;hp=727ad6a484ff0c94a1e8d76bd4a88a3dd846dc15;hpb=0af9670e1d6fe6e9dc6d38c7b28e18a5fea7d009;p=apitrace diff --git a/common/os_thread.hpp b/common/os_thread.hpp index 727ad6a..9dc656e 100644 --- a/common/os_thread.hpp +++ b/common/os_thread.hpp @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2011 Jose Fonseca + * Copyright 2011-2012 Jose Fonseca * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy @@ -24,55 +24,325 @@ **************************************************************************/ /* - * Simple OS abstraction. + * OS native thread abstraction. * - * Mimics C++11 / boost threads. + * Mimics C++11 threads. */ #ifndef _OS_THREAD_HPP_ #define _OS_THREAD_HPP_ + #ifdef _WIN32 #include #else #include #endif + +#define USE_WIN32_CONDITION_VARIABLES 0 + + +/** + * Compiler TLS. + * + * See also: + * - http://gcc.gnu.org/onlinedocs/gcc-4.6.3/gcc/Thread_002dLocal.html + * - http://msdn.microsoft.com/en-us/library/9w1sdazb.aspx + */ +#if defined(_MSC_VER) +# define thread_specific __declspec(thread) +#elif defined(__GNUC__) +# define thread_specific __thread +#else +# define thread_specific +# error "Unsupported compiler" +#endif + + namespace os { - namespace thread { + /** + * Base class for mutex and recursive_mutex. + */ + class _base_mutex + { + public: +#ifdef _WIN32 + typedef CRITICAL_SECTION native_handle_type; +#else + typedef pthread_mutex_t native_handle_type; +#endif - /** - * Thread ID - * - * XXX: Actually C++11 thread::id is not an integral type, but we rely on that. - */ + _base_mutex(void) { #ifdef _WIN32 - typedef DWORD id; + InitializeCriticalSection(&_native_handle); #else - typedef pthread_t id; + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&_native_handle, &attr); + pthread_mutexattr_destroy(&attr); #endif + } - } /* namespace thread */ + ~_base_mutex() { +#ifdef _WIN32 + DeleteCriticalSection(&_native_handle); +#else + pthread_mutex_destroy(&_native_handle); +#endif + } + inline void + lock(void) { +#ifdef _WIN32 + EnterCriticalSection(&_native_handle); +#else + pthread_mutex_lock(&_native_handle); +#endif + } - namespace this_thread { + inline void + unlock(void) { +#ifdef _WIN32 + LeaveCriticalSection(&_native_handle); +#else + pthread_mutex_unlock(&_native_handle); +#endif + } - /** - * Get current thread ID. - */ - inline thread::id - get_id(void) { + native_handle_type & native_handle() { + return _native_handle; + } + + protected: + native_handle_type _native_handle; + }; + + + /** + * Same interface as std::mutex. + */ + class mutex : public _base_mutex + { + public: + inline + mutex(void) { #ifdef _WIN32 - return GetCurrentThreadId(); + InitializeCriticalSection(&_native_handle); #else - return pthread_self(); + pthread_mutex_init(&_native_handle, NULL); #endif } + }; - } /* namespace this_thread */ + /** + * Same interface as std::recursive_mutex. + */ + class recursive_mutex : public _base_mutex + { + public: + inline + recursive_mutex(void) { +#ifdef _WIN32 + InitializeCriticalSection(&_native_handle); +#else + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&_native_handle, &attr); + pthread_mutexattr_destroy(&attr); +#endif + } + }; + + + /** + * Same interface as std::unique_lock; + */ + template< class Mutex > + class unique_lock + { + public: + typedef Mutex mutex_type; + + inline explicit + unique_lock(mutex_type & mutex) : + _mutex(&mutex) + { + _mutex->lock(); + } + + inline + ~unique_lock() { + _mutex->unlock(); + } + + inline void + lock() { + _mutex->lock(); + } + + inline void + unlock() { + _mutex->unlock(); + } + + mutex_type * + mutex() const { + return _mutex; + } + + protected: + mutex_type *_mutex; + }; + + + /** + * Same interface as std::condition_variable + */ + class condition_variable + { + private: +#ifdef _WIN32 +# if USE_WIN32_CONDITION_VARIABLES + // XXX: Only supported on Vista an higher. Not yet supported by WINE. + typedef CONDITION_VARIABLE native_handle_type; + native_handle_type _native_handle; +#else + // http://www.cs.wustl.edu/~schmidt/win32-cv-1.html + LONG cWaiters; + HANDLE hEvent; +#endif +#else + typedef pthread_cond_t native_handle_type; + native_handle_type _native_handle; +#endif + + public: + condition_variable() { +#ifdef _WIN32 +# if USE_WIN32_CONDITION_VARIABLES + InitializeConditionVariable(&_native_handle); +# else + cWaiters = 0; + hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); +# endif +#else + pthread_cond_init(&_native_handle, NULL); +#endif + } + + ~condition_variable() { +#ifdef _WIN32 +# if USE_WIN32_CONDITION_VARIABLES + /* No-op */ +# else + CloseHandle(hEvent); +# endif +#else + pthread_cond_destroy(&_native_handle); +#endif + } + + inline void + signal(void) { +#ifdef _WIN32 +# if USE_WIN32_CONDITION_VARIABLES + WakeConditionVariable(&_native_handle); +# else + if (cWaiters) { + SetEvent(hEvent); + } +# endif +#else + pthread_cond_signal(&_native_handle); +#endif + } + + inline void + wait(unique_lock & lock) { + mutex::native_handle_type & mutex_native_handle = lock.mutex()->native_handle(); +#ifdef _WIN32 +# if USE_WIN32_CONDITION_VARIABLES + SleepConditionVariableCS(&_native_handle, &mutex_native_handle, INFINITE); +# else + InterlockedIncrement(&cWaiters); + LeaveCriticalSection(&mutex_native_handle); + WaitForSingleObject(hEvent, INFINITE); + EnterCriticalSection(&mutex_native_handle); + InterlockedDecrement(&cWaiters); +# endif +#else + pthread_cond_wait(&_native_handle, &mutex_native_handle); +#endif + } + }; + + + /** + * Same interface as std::thread + */ + class thread { + public: +#ifdef _WIN32 + typedef HANDLE native_handle_type; +#else + typedef pthread_t native_handle_type; +#endif + + inline + thread() : + _native_handle(0) + { + } + + inline + thread(const thread &other) : + _native_handle(other._native_handle) + { + } + + template< class Function, class Arg > + explicit thread( Function& f, Arg arg ) { +#ifdef _WIN32 + DWORD id = 0; + _native_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)f, (LPVOID)arg, 0, &id); +#else + pthread_create(&_native_handle, NULL, ( void *(*) (void *))f, arg); +#endif + } + + inline bool + joinable(void) const { + return _native_handle != 0; + } + + inline void + join() { +#ifdef _WIN32 + WaitForSingleObject(_native_handle, INFINITE); +#else + pthread_join(_native_handle, NULL); +#endif + } + + private: + native_handle_type _native_handle; + +#if 0 +#ifdef _WIN32 + template< class Function, class Arg > + static DWORD WINAPI + ThreadProc(LPVOID lpParameter) { + + ); +#endif +#endif + }; } /* namespace os */