| //===-- PThreadMutex.h ------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Created by Greg Clayton on 6/16/07. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef __PThreadMutex_h__ |
| #define __PThreadMutex_h__ |
| |
| #include <pthread.h> |
| #include <assert.h> |
| #include <stdint.h> |
| |
| //#define DEBUG_PTHREAD_MUTEX_DEADLOCKS 1 |
| |
| #if defined (DEBUG_PTHREAD_MUTEX_DEADLOCKS) |
| #define PTHREAD_MUTEX_LOCKER(var, mutex) PThreadMutex::Locker var(mutex, __FUNCTION__, __FILE__, __LINE__) |
| |
| #else |
| #define PTHREAD_MUTEX_LOCKER(var, mutex) PThreadMutex::Locker var(mutex) |
| #endif |
| |
| class PThreadMutex |
| { |
| public: |
| |
| class Locker |
| { |
| public: |
| #if defined (DEBUG_PTHREAD_MUTEX_DEADLOCKS) |
| |
| Locker(PThreadMutex& m, const char *function, const char *file, int line); |
| Locker(PThreadMutex* m, const char *function, const char *file, int line); |
| Locker(pthread_mutex_t *mutex, const char *function, const char *file, int line); |
| ~Locker(); |
| void Lock(); |
| void Unlock(); |
| |
| #else |
| Locker(PThreadMutex& m) : |
| m_pMutex(m.Mutex()) |
| { |
| Lock(); |
| } |
| |
| Locker(PThreadMutex* m) : |
| m_pMutex(m ? m->Mutex() : NULL) |
| { |
| Lock(); |
| } |
| |
| Locker(pthread_mutex_t *mutex) : |
| m_pMutex(mutex) |
| { |
| Lock(); |
| } |
| |
| void Lock() |
| { |
| if (m_pMutex) |
| ::pthread_mutex_lock (m_pMutex); |
| } |
| |
| void Unlock() |
| { |
| if (m_pMutex) |
| ::pthread_mutex_unlock (m_pMutex); |
| } |
| |
| ~Locker() |
| { |
| Unlock(); |
| } |
| |
| #endif |
| |
| // unlock any the current mutex and lock the new one if it is valid |
| void Reset(pthread_mutex_t *pMutex = NULL) |
| { |
| Unlock(); |
| m_pMutex = pMutex; |
| Lock(); |
| } |
| pthread_mutex_t *m_pMutex; |
| #if defined (DEBUG_PTHREAD_MUTEX_DEADLOCKS) |
| const char *m_function; |
| const char *m_file; |
| int m_line; |
| uint64_t m_lock_time; |
| #endif |
| }; |
| |
| |
| PThreadMutex() |
| { |
| int err; |
| err = ::pthread_mutex_init (&m_mutex, NULL); assert(err == 0); |
| } |
| |
| PThreadMutex(int type) |
| { |
| int err; |
| ::pthread_mutexattr_t attr; |
| err = ::pthread_mutexattr_init (&attr); assert(err == 0); |
| err = ::pthread_mutexattr_settype (&attr, type); assert(err == 0); |
| err = ::pthread_mutex_init (&m_mutex, &attr); assert(err == 0); |
| err = ::pthread_mutexattr_destroy (&attr); assert(err == 0); |
| } |
| |
| ~PThreadMutex() |
| { |
| int err; |
| err = ::pthread_mutex_destroy (&m_mutex); |
| if (err != 0) |
| { |
| err = Unlock(); |
| if (err == 0) |
| ::pthread_mutex_destroy (&m_mutex); |
| } |
| } |
| |
| pthread_mutex_t *Mutex() |
| { |
| return &m_mutex; |
| } |
| |
| int Lock() |
| { |
| return ::pthread_mutex_lock (&m_mutex); |
| } |
| |
| int Unlock() |
| { |
| return ::pthread_mutex_unlock (&m_mutex); |
| } |
| |
| protected: |
| pthread_mutex_t m_mutex; |
| }; |
| |
| #endif |