Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   mutex.h Go to the documentation of this file. /* Copyright, 2000 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #ifndef NL_MUTEX_H #define NL_MUTEX_H #include "nel/misc/types_nl.h" #include "nel/misc/time_nl.h" #include <map> #ifdef NL_OS_UNIX #include <pthread.h> #include <semaphore.h> #endif #undef MUTEX_DEBUG namespace NLMISC { // By default, all mutex use the CFairMutex class to avoid freeze problem. #define CMutex CFairMutex class CUnfairMutex { public: CUnfairMutex(); CUnfairMutex(const std::string &name); ~CUnfairMutex(); void enter (); void leave (); private: #ifdef NL_OS_WINDOWS void *Mutex; #elif defined NL_OS_UNIX pthread_mutex_t mutex; #else # error "No unfair mutex implementation for this OS" #endif }; #ifdef NL_OS_WINDOWS struct TNelRtlCriticalSection { void *DebugInfo; long LockCount; long RecursionCount; void *OwningThread; // from the thread's ClientId->UniqueThread void *LockSemaphore; uint32 SpinCount; }; #endif // NL_OS_WINDOWS class CFairMutex { public: CFairMutex(); CFairMutex(const std::string &name); ~CFairMutex(); void enter (); void leave (); std::string Name; private: #ifdef NL_OS_WINDOWS TNelRtlCriticalSection _Cs; #elif defined NL_OS_UNIX volatile sem_t _Sem; #else # error "No fair mutex implementation for this OS" #endif #ifdef MUTEX_DEBUG // debug stuffs void debugCreateMutex(); void debugBeginEnter(); void debugEndEnter(); void debugLeave(); void debugDeleteMutex(); #endif // MUTEX_DEBUG }; /* * Debug info */ #ifdef MUTEX_DEBUG struct TMutexLocks { TMutexLocks(uint32 m=0) : TimeToEnter(0), TimeInMutex(0), Nb(0), WaitingMutex(0), MutexNum(m), ThreadHavingTheMutex(0xFFFFFFFF), Dead(false) {} uint32 TimeToEnter; // cumulated time blocking on enter uint32 TimeInMutex; // cumulated time between enter and leave uint32 Nb; // number of calls of enter uint32 WaitingMutex; // number of thread that waiting this mutex sint32 MutexNum; // identifying a mutex uint ThreadHavingTheMutex; // thread id of the thread that is in this mutex (0xFFFFFFFF if no thread) bool Dead; // True if the mutex is dead (deleted) std::string MutexName; // Name of the mutex NLMISC::TTicks BeginEnter; NLMISC::TTicks EndEnter; }; void initAcquireTimeMap(); std::map<CMutex*,TMutexLocks> getNewAcquireTimes(); extern uint32 NbMutexes; #endif // MUTEX_DEBUG // By default, all synchronization use the CFairSynchronized class to avoid freeze problem. #define CSynchronized CFairSynchronized template <class T> class CUnfairSynchronized { public: CUnfairSynchronized (const std::string &name) : _Mutex(name) { } class CAccessor { CUnfairSynchronized<T> *Synchronized; public: CAccessor(CUnfairSynchronized<T> *cs) { Synchronized = cs; const_cast<CMutex&>(Synchronized->_Mutex).enter(); } ~CAccessor() { const_cast<CMutex&>(Synchronized->_Mutex).leave(); } T &value() { return const_cast<T&>(Synchronized->_Value); } }; private: friend class CUnfairSynchronized::CAccessor; volatile CUnfairMutex _Mutex; volatile T _Value; }; template <class T> class CFairSynchronized { public: CFairSynchronized (const std::string &name) : _Cs(name) { } class CAccessor { CFairSynchronized<T> *Synchronized; public: CAccessor(CFairSynchronized<T> *cs) { Synchronized = cs; const_cast<CFairMutex&>(Synchronized->_Cs).enter(); } ~CAccessor() { const_cast<CFairMutex&>(Synchronized->_Cs).leave(); } T &value() { return const_cast<T&>(Synchronized->_Value); } }; private: friend class CFairSynchronized::CAccessor; volatile CFairMutex _Cs; volatile T _Value; }; } // NLMISC #endif // NL_MUTEX_H /* End of mutex.h */