nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 #ifndef _GNU_SOURCE
+00029 #define _GNU_SOURCE
+00030 #endif // _GNU_SOURCE
+00031 
+00032 #include "nel/misc/mutex.h"
+00033 #include "nel/misc/time_nl.h"
+00034 
+00035 #ifdef MUTEX_DEBUG
+00036 #include <iostream>
+00037 #endif
+00038 
+00039 using namespace std;
+00040 
+00041 #ifndef MUTEX_DEBUG
+00042 #define debugCreateMutex() ;
+00043 #define debugBeginEnter() ;
+00044 #define debugEndEnter() ;
+00045 #define debugLeave() ;
+00046 #define debugDeleteMutex() ;
+00047 #endif
+00048 
+00049 
+00050 /****************
+00051  * Windows code *
+00052  ****************/
+00053 
+00054 #ifdef NL_OS_WINDOWS
+00055 
+00056 // these defines are for IsDebuggerPresent(). It'll not compile on windows 95
+00057 // just comment this and the IsDebuggerPresent to compile on windows 95
+00058 #define _WIN32_WINDOWS  0x0410
+00059 #define WINVER                  0x0400
+00060 #include <windows.h>
+00061 
+00062 
+00063 namespace NLMISC {
+00064 
+00065 
+00066 /*
+00067  * Windows version
+00068  */
+00069 
+00070 CUnfairMutex::CUnfairMutex()
+00071 {
+00072         // Create a mutex with no initial owner.
+00073         Mutex = (void *) CreateMutex (NULL, FALSE, NULL);
+00074         nlassert (Mutex != NULL);
+00075 }
+00076 
+00077 
+00078 CUnfairMutex::CUnfairMutex(const std::string &name)
+00079 {
+00080         // Create a mutex with no initial owner.
+00081         Mutex = (void *) CreateMutex (NULL, FALSE, NULL);
+00082         nlassert (Mutex != NULL);
+00083 }
+00084 
+00085 
+00086 /*
+00087  * Windows version
+00088  */
+00089 CUnfairMutex::~CUnfairMutex()
+00090 {
+00091         CloseHandle( Mutex );
+00092 }
+00093 
+00094 
+00095 /*
+00096  * Windows version
+00097  */
+00098 void CUnfairMutex::enter()
+00099 {
+00100 #ifdef NL_DEBUG
+00101         DWORD timeout;
+00102         if ( IsDebuggerPresent() )
+00103                 timeout = INFINITE;
+00104         else
+00105                 timeout = 10000;
+00106 
+00107     // Request ownership of mutex
+00108         DWORD dwWaitResult = WaitForSingleObject (Mutex, timeout);
+00109 #else
+00110     // Request ownership of mutex during 10s
+00111         DWORD dwWaitResult = WaitForSingleObject (Mutex, 10000);
+00112 #endif // NL_DEBUG
+00113         switch (dwWaitResult)
+00114         {
+00115         // The thread got mutex ownership.
+00116         case WAIT_OBJECT_0:             break;
+00117         // Cannot get mutex ownership due to time-out.
+00118         case WAIT_TIMEOUT:              nlerror ("Dead lock in a mutex (or more that 10s for the critical section");
+00119         // Got ownership of the abandoned mutex object.
+00120         case WAIT_ABANDONED:    nlerror ("A thread forgot to release the mutex");
+00121     }
+00122 }
+00123 
+00124 
+00125 /*
+00126  * Windows version
+00127  */
+00128 void CUnfairMutex::leave()
+00129 {
+00130         if (ReleaseMutex(Mutex) == 0)
+00131         {
+00132                 nlerror ("error while releasing the mutex (0x%x %d), %p", GetLastError(), GetLastError(), Mutex);
+00133         }
+00134 }
+00135 
+00136 
+00137 /*
+00138  * Windows version
+00139  */
+00140 CFairMutex::CFairMutex()
+00141 {
+00142         Name = "unset mutex name";
+00143 
+00144         debugCreateMutex();
+00145 
+00146         // Check that the CRITICAL_SECTION structure has not changed
+00147         nlassert( sizeof(TNelRtlCriticalSection)==sizeof(CRITICAL_SECTION) );
+00148 
+00149 #if (_WIN32_WINNT >= 0x0500)
+00150         DWORD dwSpinCount = 0x80000000; // set high-order bit to use preallocation
+00151         if ( ! InitializeCriticalSectionAndSpinCount( &_Cs, dwSpinCount ) )
+00152         {
+00153                 nlerror( "Error entering critical section" );
+00154         }
+00155 #else
+00156         InitializeCriticalSection( (CRITICAL_SECTION*)&_Cs );
+00157 #endif
+00158 }
+00159 
+00160 
+00161 CFairMutex::CFairMutex(const string &name)
+00162 {
+00163         Name = name;
+00164 
+00165 #ifdef MUTEX_DEBUG
+00166         debugCreateMutex();
+00167 #endif
+00168 
+00169         // Check that the CRITICAL_SECTION structure has not changed
+00170         nlassert( sizeof(TNelRtlCriticalSection)==sizeof(CRITICAL_SECTION) );
+00171 
+00172 #if (_WIN32_WINNT >= 0x0500)
+00173         DWORD dwSpinCount = 0x80000000; // set high-order bit to use preallocation
+00174         if ( ! InitializeCriticalSectionAndSpinCount( &_Cs, dwSpinCount ) )
+00175         {
+00176                 nlerror( "Error entering critical section" );
+00177         }
+00178 #else
+00179         InitializeCriticalSection( (CRITICAL_SECTION*)&_Cs );
+00180 #endif
+00181 }
+00182 
+00183 
+00184 
+00185 /*
+00186  * Windows version
+00187  */
+00188 CFairMutex::~CFairMutex()
+00189 {
+00190         DeleteCriticalSection( (CRITICAL_SECTION*)&_Cs );
+00191 
+00192         debugDeleteMutex();
+00193 }
+00194 
+00195 
+00196 /*
+00197  * Windows version
+00198  */
+00199 void CFairMutex::enter()
+00200 {
+00201         debugBeginEnter();
+00202 
+00203         EnterCriticalSection( (CRITICAL_SECTION*)&_Cs );
+00204 
+00205         debugEndEnter();
+00206 }
+00207 
+00208 
+00209 /*
+00210  * Windows version
+00211  */
+00212 void CFairMutex::leave()
+00213 {
+00214         LeaveCriticalSection( (CRITICAL_SECTION*)&_Cs );
+00215 
+00216         debugLeave();
+00217 }
+00218 
+00219 
+00220 
+00221 
+00222 
+00223 
+00224 
+00225 
+00226 /*************
+00227  * Unix code *
+00228  *************/
+00229 
+00230 #elif defined NL_OS_UNIX
+00231 
+00232 #include <pthread.h>
+00233 #include <errno.h>
+00234 
+00235 
+00236 /*
+00237  * Clanlib authors say: "We need to do this because the posix threads library
+00238  * under linux obviously suck:"
+00239  */
+00240 extern "C"
+00241 {
+00242         int pthread_mutexattr_setkind_np( pthread_mutexattr_t *attr, int kind );
+00243 }
+00244 
+00245 
+00246 namespace NLMISC {
+00247 
+00248 
+00249 /*
+00250  * Unix version
+00251  */
+00252 CUnfairMutex::CUnfairMutex(const std::string &name)
+00253 {
+00254         pthread_mutexattr_t attr;
+00255         pthread_mutexattr_init( &attr );
+00256         // Fast mutex. Note: on Windows all mutexes are recursive
+00257         pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_ADAPTIVE_NP ); //PTHREAD_MUTEX_ERRORCHECK_NP );//PTHREAD_MUTEX_ADAPTIVE_NP );//PTHREAD_MUTEX_RECURSIVE_NP );
+00258         pthread_mutex_init( &mutex, &attr );
+00259         pthread_mutexattr_destroy( &attr );
+00260 }
+00261 
+00262 
+00263 /*
+00264  * Unix version
+00265  */
+00266 CUnfairMutex::~CUnfairMutex()
+00267 {
+00268         pthread_mutex_destroy( &mutex );
+00269 }
+00270 
+00271 
+00272 /*
+00273  * Unix version
+00274  */
+00275 void CUnfairMutex::enter()
+00276 {
+00277         //cout << getpid() << ": Locking " << &mutex << endl;
+00278         if ( pthread_mutex_lock( &mutex ) != 0 )
+00279         {
+00280           //cout << "Error locking a mutex " << endl;
+00281                 nlerror( "Error locking a mutex" );
+00282         }
+00283         /*else
+00284         {
+00285           cout << getpid() << ": Owning " << &mutex << endl;
+00286         }*/
+00287 }
+00288 
+00289 
+00290 /*
+00291  * Unix version
+00292  */
+00293 void CUnfairMutex::leave()
+00294 {
+00295         //int errcode;
+00296         //cout << getpid() << ": Unlocking " << &mutex << endl;
+00297         if ( (/*errcode=*/pthread_mutex_unlock( &mutex )) != 0 )
+00298         {
+00299          /* switch ( errcode )
+00300             {
+00301             case EINVAL: cout << "INVAL" << endl; break;
+00302             case EPERM: cout << "PERM" << endl; break;
+00303             default: cout << "OTHER" << endl;
+00304             }
+00305           */
+00306           //cout << "Error unlocking a mutex " /*<< &mutex*/ << endl;
+00307                 nlerror( "Error unlocking a mutex" );
+00308         }
+00309         /*else
+00310         {
+00311           cout << getpid() << ": Released " << &mutex << endl;
+00312         }*/
+00313 }
+00314 
+00315 
+00316 /*
+00317  * Unix version
+00318  */
+00319 CFairMutex::CFairMutex()
+00320 {
+00321         sem_init( const_cast<sem_t*>(&_Sem), 0, 1 );
+00322 }
+00323 
+00324 
+00325 CFairMutex::CFairMutex( const std::string &name )
+00326 {
+00327         sem_init( const_cast<sem_t*>(&_Sem), 0, 1 );
+00328 }
+00329 
+00330 
+00331 /*
+00332  * Unix version
+00333  */
+00334 CFairMutex::~CFairMutex()
+00335 {
+00336         sem_destroy( const_cast<sem_t*>(&_Sem) ); // needs that no thread is waiting on the semaphore
+00337 }
+00338 
+00339 
+00340 /*
+00341  * Unix version
+00342  */
+00343 void CFairMutex::enter()
+00344 {
+00345         sem_wait( const_cast<sem_t*>(&_Sem) );
+00346 }
+00347 
+00348 
+00349 /*
+00350  * Unix version
+00351  */
+00352 void CFairMutex::leave()
+00353 {
+00354         sem_post( const_cast<sem_t*>(&_Sem) );
+00355 }
+00356 
+00357 
+00358 #endif // NL_OS_WINDOWS/NL_OS_LINUX
+00359 
+00360 
+00361 
+00362 
+00363 
+00364 
+00365 
+00366 /******************
+00367  * Debugging code *
+00368  ******************/
+00369         
+00370 #ifdef MUTEX_DEBUG
+00371 
+00372 map<CFairMutex*,TMutexLocks>    *AcquireTime = NULL;
+00373 uint32                                          NbMutexes = 0;
+00374 CFairMutex                                              *ATMutex = NULL;
+00375 bool                                            InitAT = true;
+00376 
+00377 
+00379 void initAcquireTimeMap()
+00380 {
+00381         if ( InitAT )
+00382         {
+00383                 ATMutex = new CFairMutex("ATMutex");
+00384                 AcquireTime = new map<CFairMutex*,TMutexLocks>;
+00385                 InitAT = false;
+00386         }
+00387 }
+00388 
+00389 
+00391 map<CFairMutex*,TMutexLocks>    getNewAcquireTimes()
+00392 {
+00393         map<CMutex*,TMutexLocks>        m;
+00394         ATMutex->enter();
+00395 
+00396         // Copy map
+00397         m = *AcquireTime;
+00398 
+00399         // Reset map
+00400 /*      map<CMutex*,TMutexLocks>::iterator im;
+00401         for ( im=AcquireTime->begin(); im!=AcquireTime->end(); ++im )
+00402         {
+00403                 (*im).second.Time = 0;
+00404                 (*im).second.Nb = 0;
+00405                 (*im).second.Locked = false;
+00406         }
+00407 */
+00408         ATMutex->leave();
+00409         return m;
+00410 }
+00411 
+00412 
+00415 
+00416 void CFairMutex::debugCreateMutex()
+00417 {
+00418 /*      if ( ! InitAT )
+00419         {
+00420                 ATMutex->enter();
+00421                 AcquireTime->insert( make_pair( this, TMutexLocks(NbMutexes) ) );
+00422                 NbMutexes++;
+00423                 ATMutex->leave();
+00424                 char dbgstr [256];
+00425                 smprintf( dbgstr, 256, "MUTEX: Creating mutex %p %s (number %u)\n", this, Name.c_str(), NbMutexes-1 );
+00426 #ifdef NL_OS_WINDOWS
+00427                 if ( IsDebuggerPresent() )
+00428                         OutputDebugString( dbgstr );
+00429 #endif
+00430                 cout << dbgstr << endl;
+00431         }
+00432 */}
+00433 
+00434 void CFairMutex::debugDeleteMutex()
+00435 {
+00436         if ( (this!=ATMutex ) && (ATMutex!=NULL) )
+00437         {
+00438                 ATMutex->enter();
+00439                 (*AcquireTime)[this].Dead = true;
+00440                 ATMutex->leave();
+00441         }
+00442 }
+00443 
+00444 void CFairMutex::debugBeginEnter()
+00445 {
+00446         if ( (this!=ATMutex ) && (ATMutex!=NULL) )
+00447         {
+00448                 TTicks t = CTime::getPerformanceTime();
+00449 
+00450                 ATMutex->enter();
+00451                 std::map<CMutex*,TMutexLocks>::iterator it = (*AcquireTime).find (this);
+00452                 if (it == (*AcquireTime).end())
+00453                 {
+00454                         AcquireTime->insert( make_pair( this, TMutexLocks(NbMutexes++) ) );
+00455                         char dbgstr [256];
+00456                         smprintf( dbgstr, 256, "MUTEX: Creating mutex %p %s (number %u)\n", this, Name.c_str(), NbMutexes-1 );
+00457 #ifdef NL_OS_WINDOWS
+00458                         if ( IsDebuggerPresent() ) OutputDebugString( dbgstr );
+00459 #endif
+00460                         cout << dbgstr << endl;
+00461 
+00462                         it = (*AcquireTime).find (this);
+00463                         (*it).second.MutexName = Name;
+00464                 }
+00465                 (*it).second.WaitingMutex++;
+00466                 (*it).second.BeginEnter = t;
+00467                 ATMutex->leave();
+00468         }
+00469 }
+00470 
+00471 
+00472 void CFairMutex::debugEndEnter()
+00473 {
+00474 //      printf("1");
+00475 /*      char str[1024];
+00476         sprintf(str, "enter %8p %8p %8p\n", this, Mutex, getThreadId ());
+00477         if (Mutex == (void*)0x88)
+00478         {
+00479                 OutputDebugString (str);
+00480                 if (entered) __asm int 3;
+00481                 entered = true;
+00482         }
+00483 */
+00484         if ( ( this != ATMutex ) && ( ATMutex != NULL ) )
+00485         {
+00486                 TTicks t = CTime::getPerformanceTime();
+00487                 ATMutex->enter();
+00488                 if ((uint32)(t-(*AcquireTime)[this].BeginEnter) > (*AcquireTime)[this].TimeToEnter)
+00489                         (*AcquireTime)[this].TimeToEnter = (uint32)(t-(*AcquireTime)[this].BeginEnter);
+00490                 (*AcquireTime)[this].Nb += 1;
+00491                 (*AcquireTime)[this].WaitingMutex--;
+00492                 (*AcquireTime)[this].ThreadHavingTheMutex = getThreadId();
+00493                 (*AcquireTime)[this].EndEnter = t;
+00494                 ATMutex->leave();
+00495         }
+00496 }
+00497 
+00498 
+00499 void CFairMutex::debugLeave()
+00500 {
+00501 //      printf( "0" );
+00502 /*      char str[1024];
+00503         sprintf(str, "leave %8p %8p %8p\n", this, Mutex, getThreadId ());
+00504         if (Mutex == (void*)0x88)
+00505         {
+00506                 OutputDebugString (str);
+00507                 if (!entered) __asm int 3;
+00508                 entered = false;
+00509         }
+00510 */
+00511 
+00512         if ( ( this != ATMutex ) && ( ATMutex != NULL ) )
+00513         {
+00514                 TTicks Leave = CTime::getPerformanceTime();
+00515                 ATMutex->enter();
+00516                 if ((uint32)(Leave-(*AcquireTime)[this].EndEnter) > (*AcquireTime)[this].TimeInMutex)
+00517                         (*AcquireTime)[this].TimeInMutex = (uint32)(Leave-(*AcquireTime)[this].EndEnter);
+00518                 (*AcquireTime)[this].Nb += 1;
+00519                 (*AcquireTime)[this].WaitingMutex = false;
+00520                 (*AcquireTime)[this].ThreadHavingTheMutex = 0xFFFFFFFF;
+00521                 ATMutex->leave();
+00522         }
+00523 
+00524 }
+00525 
+00526 #endif // MUTEX_DEBUG
+00527 
+00528 } // NLMISC
+
mutex.cpp
