X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Fos_thread.hpp;h=5e9577b56a29924b816abfc10fb16baf70a9bb14;hb=be6b2e76b2a5c529eec85cab10732444143c87d5;hp=b17563fa5428d2ac80a4b5d18adf916c6c69ac75;hpb=0e47f66f21683a18f34282e07efa85cdac4fe0e0;p=apitrace diff --git a/common/os_thread.hpp b/common/os_thread.hpp index b17563f..5e9577b 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,9 +24,9 @@ **************************************************************************/ /* - * Simple OS abstraction. + * OS native thread abstraction. * - * Mimics C++11 / boost threads. + * Mimics C++11 threads. */ #ifndef _OS_THREAD_HPP_ @@ -39,10 +39,34 @@ #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 { - class recursive_mutex + /** + * Base class for mutex and recursive_mutex. + */ + class _base_mutex { public: #ifdef _WIN32 @@ -51,19 +75,19 @@ namespace os { typedef pthread_mutex_t native_handle_type; #endif - recursive_mutex(void) { + _base_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, NULL); + pthread_mutex_init(&_native_handle, &attr); pthread_mutexattr_destroy(&attr); #endif } - ~recursive_mutex() { + ~_base_mutex() { #ifdef _WIN32 DeleteCriticalSection(&_native_handle); #else @@ -89,73 +113,235 @@ namespace os { #endif } - private: + native_handle_type & native_handle() { + return _native_handle; + } + + protected: native_handle_type _native_handle; }; - template - class thread_specific_ptr + /** + * Same interface as std::mutex. + */ + class mutex : public _base_mutex { - private: + public: + inline + mutex(void) { +#ifdef _WIN32 + InitializeCriticalSection(&_native_handle); +#else + pthread_mutex_init(&_native_handle, NULL); +#endif + } + }; + + + /** + * Same interface as std::recursive_mutex. + */ + class recursive_mutex : public _base_mutex + { + public: + inline + recursive_mutex(void) { #ifdef _WIN32 - DWORD dwTlsIndex; + InitializeCriticalSection(&_native_handle); #else - pthread_key_t key; + 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 + } + }; - static void destructor(void *ptr) { - delete static_cast(ptr); + + /** + * 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: - thread_specific_ptr(void) { + 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 - dwTlsIndex = TlsAlloc(); +# if USE_WIN32_CONDITION_VARIABLES + /* No-op */ +# else + CloseHandle(hEvent); +# endif #else - pthread_key_create(&key, &destructor); + pthread_cond_destroy(&_native_handle); #endif } - ~thread_specific_ptr() { + inline void + signal(void) { #ifdef _WIN32 - TlsFree(dwTlsIndex); +# if USE_WIN32_CONDITION_VARIABLES + WakeConditionVariable(&_native_handle); +# else + if (cWaiters) { + SetEvent(hEvent); + } +# endif #else - pthread_key_delete(key); + pthread_cond_signal(&_native_handle); #endif } - T* get(void) const { - void *ptr; + inline void + wait(unique_lock & lock) { + mutex::native_handle_type & mutex_native_handle = lock.mutex()->native_handle(); #ifdef _WIN32 - ptr = TlsGetValue(dwTlsIndex); +# 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 - ptr = pthread_getspecific(key); + pthread_cond_wait(&_native_handle, &mutex_native_handle); #endif - return static_cast(ptr); } + }; - T* operator -> (void) const + + /** + * 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) { - return get(); } - T& operator * (void) const + inline + thread(thread &other) : + _native_handle(other._native_handle) { - return *get(); } - void reset(T* new_value=0) { - T * old_value = get(); + template< class Function, class Arg > + explicit thread( Function& f, Arg arg ) { #ifdef _WIN32 - TlsSetValue(dwTlsIndex, new_value); + DWORD id = 0; + _native_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)f, (LPVOID)arg, 0, &id); #else - pthread_setspecific(key, new_value); + pthread_create(&_native_handle, NULL, ( void *(*) (void *))f, arg); #endif - if (old_value) { - delete old_value; - } } + + 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 */