/ray/src/lib/threads/mutex.h

Go to the documentation of this file.

/*
 * lib/threads/mutex.h
 * 
 * Implementing mutual exclusion classes for thread synchronisation. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _ThreadLibrary_Mutex_H_
#define _ThreadLibrary_Mutex_H_ 1

#include <lib/sconfig.h>    /* MUST be first */

/* Can we use our own pthreads-based implementation? This should be faster.*/
#if USE_PRIVATE__PTHREADS
# include <errno.h>   /* for EGAGIN */
# include <pthread.h>
#else
# include <glib/gthread.h>
#endif  /* USE_PRIVATE__PTHREADS */

class WaitCondition;

class /*_packed_*/ FastMutex
{
    friend class WaitCondition;
    private:
#if USE_PRIVATE__PTHREADS
        pthread_mutex_t m;
#else
        GStaticMutex m;
#endif
        
    public:
        FastMutex();
        
        inline ~FastMutex()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_destroy(&m);  }
#else
            {  g_static_mutex_free(&m);  }
#endif
        
        inline void lock()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_lock(&m);  }
#else
            {  g_static_mutex_lock(&m);  }
#endif
        
        inline bool test()
#if USE_PRIVATE__PTHREADS
            {  return(pthread_mutex_trylock(&m)!=EBUSY);  }
#else
            {  return(g_static_mutex_trylock(&m));  }
#endif
        
        inline void unlock()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_unlock(&m);  }
#else
            {  g_static_mutex_unlock(&m);  }
#endif
        
};


class /*_packed_*/ RecursiveMutex
{
    private:
#if USE_PRIVATE__PTHREADS
        pthread_mutex_t m;
#else
        GStaticRecMutex m;
#endif
        
    public:
        RecursiveMutex();
        inline ~RecursiveMutex()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_destroy(&m);  }
#else
            {  g_static_rec_mutex_free(&m);  }
#endif
        
        inline void lock()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_lock(&m);  }
#else
            {  g_static_rec_mutex_lock(&m);  }
#endif
        
        inline bool test()
#if USE_PRIVATE__PTHREADS
            {  return(pthread_mutex_trylock(&m)!=EBUSY);  }
#else
            {  return(g_static_rec_mutex_trylock(&m));  }
#endif
        
        inline void unlock()
#if USE_PRIVATE__PTHREADS
            {  pthread_mutex_unlock(&m);  }
#else
            {  g_static_rec_mutex_unlock(&m);  }
#endif
        
};


#if USE_PRIVATE__PTHREADS
typedef FastMutex ConditionMutex;   // This rocks!
#else

class ConditionMutex
{
    friend class WaitCondition;
    private:
        GMutex *m;
        
    public:
        ConditionMutex()  {  m=g_mutex_new();  }
        ~ConditionMutex()  {  g_mutex_free(m);  }
        
        inline void lock()  {  g_mutex_lock(m);  }
        inline bool test()  {  return(g_mutex_trylock(m));  }
        inline void unlock()  {  g_mutex_unlock(m);  }
};
#endif  /* !USE_PRIVATE__PTHREADS */


template<typename MUTEX>class MutexLock
{
    private:
        MUTEX &m;
    
    public:
        inline MutexLock(MUTEX &mutex) : m(mutex)  {  m.lock();  }
        inline ~MutexLock()  {  m.unlock();  }
        
        inline MUTEX *operator->()  {  return(&m);  }
};


#endif  /* _ThreadLibrary_Semaphore_H_ */

---