Source/Base/Threading/OSGLock.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2003 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include "OSGConfig.h"
  43
  44 #include <iostream>
  45 #include "OSGLock.h"
  46 #include "OSGBaseFunctions.h"
  47 #include "OSGThreadManager.h"
  48 #include "OSGLog.h"
  49
  50 OSG_USING_NAMESPACE
  51
  52 //---------------------------------------------------------------------------
  53 //  Class
  54 //---------------------------------------------------------------------------
  55
  56 /*--------------------------- Constructors --------------------------------*/
  57
  58 LockCommonBase::LockCommonBase(void) :
  59      Inherited(NULL, true),
  60     _uiLockId (0   )
  61 {
  62 }
  63
  64 LockCommonBase::LockCommonBase(const Char8  *szName,
  65                                      UInt32  uiId,
  66                                      bool    bGlobal):
  67      Inherited(szName, bGlobal),
  68     _uiLockId (uiId  )
  69 {
  70 }
  71
  72 /*---------------------------- Destructor ---------------------------------*/
  73
  74 LockCommonBase::~LockCommonBase(void)
  75 {
  76 }
  77
  78
  79
  80 #if defined (OSG_USE_PTHREADS)
  81
  82 //---------------------------------------------------------------------------
  83 //  Class
  84 //---------------------------------------------------------------------------
  85
  86 /*--------------------------- Constructors --------------------------------*/
  87
  88 PThreadLockBase::PThreadLockBase(void):
  89      Inherited    (),
  90     _pLowLevelLock()
  91 {
  92 }
  93
  94 PThreadLockBase::PThreadLockBase(const Char8  *szName,
  95                                        UInt32  uiId,
  96                                        bool    bGlobal) :
  97     Inherited    (szName, uiId, bGlobal),
  98     _pLowLevelLock()
  99 {
 100 }
 101
 102 /*---------------------------- Destructor ---------------------------------*/
 103
 104 PThreadLockBase::~PThreadLockBase(void)
 105 {
 106 }
 107
 108 /*--------------------------- Construction --------------------------------*/
 109
 110 bool PThreadLockBase::init(void)
 111 {
 112     pthread_mutexattr_t lockAttr;
 113
 114     pthread_mutexattr_init(&lockAttr);
 115
 116     pthread_mutexattr_settype(&lockAttr, PTHREAD_MUTEX_RECURSIVE);
 117
 118     pthread_mutex_init(&(_pLowLevelLock), &lockAttr);
 119
 120     return true;
 121 }
 122
 123 /*--------------------------- Destruction ---------------------------------*/
 124
 125 void PThreadLockBase::shutdown(void)
 126 {
 127     pthread_mutex_destroy(&(_pLowLevelLock));
 128 }
 129
 130
 131 #endif /* OSG_USE_PTHREADS */
 132
 133
 134
 135
 136 #if defined (OSG_USE_SPROC)
 137
 138 //---------------------------------------------------------------------------
 139 //  Class
 140 //---------------------------------------------------------------------------
 141
 142 /*--------------------------- Constructors --------------------------------*/
 143
 144 SprocLockBase::SprocLockBase(void):
 145      Inherited    (    ),
 146 #ifdef OSG_SPROC_USE_LOCK
 147     _pLowLevelLock(NULL)
 148 #else
 149     _pLowLevelSema(NULL)
 150 #endif
 151 {
 152 }
 153
 154 SprocLockBase::SprocLockBase(const Char8  *szName,
 155                                    UInt32  uiId  ):
 156      Inherited    (szName, uiId),
 157     _pLowLevelLock(NULL        )
 158 #ifdef OSG_SPROC_USE_LOCK
 159     _pLowLevelLock(NULL        )
 160 #else
 161     _pLowLevelSema(NULL        )
 162 #endif
 163 {
 164 }
 165
 166 /*---------------------------- Destructor ---------------------------------*/
 167
 168 SprocLockBase::~SprocLockBase(void)
 169 {
 170 }
 171
 172 /*--------------------------- Construction --------------------------------*/
 173
 174 bool SprocLockBase::init(void)
 175 {
 176     ThreadManager *pThreadManager = ThreadManager::the();
 177
 178     if(pThreadManager == NULL)
 179         return false;
 180
 181     if(pThreadManager->getArena() == NULL)
 182         return false;
 183
 184 #ifdef OSG_SPROC_USE_LOCK
 185     _pLowLevelLock = usnewlock(pThreadManager->getArena());
 186
 187     if(_pLowLevelLock == NULL)
 188         return false;
 189
 190     usinitlock(_pLowLevelLock);
 191
 192 #else
 193     _pLowLevelSema = usnewsema(pThreadManager->getArena(), 1);
 194
 195     if(_pLowLevelSema == NULL)
 196         return false;
 197
 198     usinitsema(_pLowLevelSema, 1);
 199     usctlsema (_pLowLevelSema, CS_RECURSIVEON, NULL);
 200 #endif
 201
 202     return true;
 203 }
 204
 205 /*--------------------------- Destruction ---------------------------------*/
 206
 207 void SprocLockBase::shutdown(void)
 208 {
 209     ThreadManager *pThreadManager = ThreadManager::the();
 210
 211     if(pThreadManager == NULL)
 212         return;
 213
 214     if(pThreadManager->getArena() == NULL)
 215         return;
 216
 217 #ifdef OSG_SPROC_USE_LOCK
 218     if(_pLowLevelLock != NULL)
 219     {
 220         usfreelock(_pLowLevelLock, pThreadManager->getArena());
 221
 222         _pLowLevelLock = NULL;
 223     }
 224 #else
 225     if(_pLowLevelSema != NULL)
 226     {
 227         usfreesema(_pLowLevelSema, pThreadManager->getArena());
 228
 229         _pLowLevelSema = NULL;
 230     }
 231 #endif
 232 }
 233
 234 /*------------------------------- Lock ------------------------------------*/
 235
 236 #endif /* OSG_USE_SPROC */
 237
 238
 239
 240 #if defined (OSG_USE_WINTHREADS)
 241
 242 //---------------------------------------------------------------------------
 243 //  Class
 244 //---------------------------------------------------------------------------
 245
 246 /*--------------------------- Constructors --------------------------------*/
 247
 248 WinThreadLockBase::WinThreadLockBase(void) :
 249        Inherited(    )
 250 #ifdef OSG_WINLOCK_USE_MUTEX
 251     , _pMutex   (NULL)
 252 #endif
 253 {
 254 }
 255
 256 WinThreadLockBase::WinThreadLockBase(const Char8  *szName,
 257                                            UInt32  uiId,
 258                                            bool    bGlobal) :
 259     Inherited(szName, uiId, bGlobal)
 260 #ifdef OSG_WINLOCK_USE_MUTEX
 261     , _pMutex   (NULL        )
 262 #endif
 263 {
 264 }
 265
 266 /*---------------------------- Destructor ---------------------------------*/
 267
 268 WinThreadLockBase::~WinThreadLockBase(void)
 269 {
 270 }
 271
 272 /*-------------------------- Construction ---------------------------------*/
 273
 274 bool WinThreadLockBase::init(void)
 275 {
 276 #ifdef OSG_WINLOCK_USE_MUTEX
 277     _pMutex = CreateMutex( NULL,     // no security attributes
 278                            FALSE,    // initially not owned
 279                           _szName);  // name of mutex
 280
 281     if(_pMutex == NULL)
 282     {
 283         return false;
 284     }
 285
 286     return true;
 287 #else
 288     InitializeCriticalSection(&_pCriticalSection);
 289
 290     return true;
 291 #endif
 292 }
 293
 294 /*-------------------------- Destruction ----------------------------------*/
 295
 296 void WinThreadLockBase::shutdown(void)
 297 {
 298 #ifdef OSG_WINLOCK_USE_MUTEX
 299     if(_pMutex != NULL)
 300     {
 301         CloseHandle(_pMutex);
 302         _pMutex = NULL;
 303     }
 304 #else
 305     DeleteCriticalSection(&_pCriticalSection);
 306 #endif
 307 }
 308
 309 #endif /* OSG_USE_WINTHREADS */
 310
 311
 312
 313 //---------------------------------------------------------------------------
 314 //  Class
 315 //---------------------------------------------------------------------------
 316
 317 MPLockType Lock::_type("OSGLock", "OSGMPBase", &Lock::create);
 318
 319 /*------------------------------- Get -------------------------------------*/
 320
 321 Lock::ObjTransitPtr Lock::get(const Char8 *szName, bool bGlobal)
 322 {
 323     return ThreadManager::the()->getLock(szName, bGlobal, "OSGLock");
 324 }
 325
 326 Lock *Lock::find(const Char8 *szName)
 327 {
 328     return ThreadManager::the()->findLock(szName);
 329 }
 330
 331
 332 /*------------------------------ Create -----------------------------------*/
 333
 334 Lock *Lock::create(const Char8 *szName, UInt32 uiId, bool bGlobal)
 335 {
 336     Lock *returnValue = NULL;
 337
 338     returnValue = new Lock(szName, uiId, bGlobal);
 339
 340     if(returnValue->init() == false)
 341     {
 342         delete returnValue;
 343         returnValue = NULL;
 344     }
 345
 346     return returnValue;
 347 }
 348
 349 /*--------------------------- Constructors --------------------------------*/
 350
 351 Lock::Lock(void) :
 352     Inherited()
 353 {
 354 }
 355
 356 Lock::Lock(const Char8 *szName, UInt32 uiId, bool bGlobal) :
 357     Inherited(szName, uiId, bGlobal)
 358 {
 359 }
 360
 361 /*---------------------------- Destructor ---------------------------------*/
 362
 363 Lock::~Lock(void)
 364 {
 365     _bGlobal = false;
 366
 367     ThreadManager::the()->remove(this);
 368
 369     shutdown();
 370 }
 371
 372
 373
 374 //---------------------------------------------------------------------------
 375 //  Class
 376 //---------------------------------------------------------------------------
 377
 378 MPLockPoolType LockPool::_type("OSGLockPool", "OSGMPBase", &LockPool::create);
 379
 380 /*-------------------------------------------------------------------------*/
 381 /*                                Get                                      */
 382
 383 LockPool::ObjTransitPtr LockPool::get(const Char8 *szName, bool bGlobal)
 384 {
 385     return ThreadManager::the()->getLockPool(szName,
 386                                              bGlobal,
 387                                              "OSGLockPool");
 388 }
 389
 390 LockPool *LockPool::find(const Char8 *szName)
 391 {
 392     return ThreadManager::the()->findLockPool(szName);
 393 }
 394
 395 /*------------------------------ Create -----------------------------------*/
 396
 397 LockPool *LockPool::create(const Char8 *szName,
 398                                  UInt32 uiId,
 399                                  bool   bGlobal)
 400 {
 401     LockPool *returnValue = NULL;
 402
 403     returnValue = new LockPool(szName, uiId, bGlobal);
 404
 405     if(returnValue->init() == false)
 406     {
 407         returnValue = NULL;
 408     }
 409
 410     return returnValue;
 411 }
 412
 413 /*--------------------------- Constructors --------------------------------*/
 414
 415 LockPool::LockPool(const Char8  *szName,
 416                          UInt32  uiId,
 417                          bool    bGlobal) :
 418     Inherited(szName, uiId, bGlobal)
 419 {
 420 }
 421
 422 /*---------------------------- Destructor ---------------------------------*/
 423
 424 LockPool::~LockPool(void)
 425 {
 426     _bGlobal = false;
 427
 428     ThreadManager::the()->remove(this);
 429
 430     shutdown();
 431 }
 432
 433 /*--------------------------- Construction --------------------------------*/
 434
 435 bool LockPool::init(void)
 436 {
 437     bool   returnValue = true;
 438     Char8 *pTmp;
 439
 440     pTmp = new Char8[strlen(_szName) + 6];
 441
 442     for(UInt32 i = 0; i < uiLockPoolSize; i++)
 443     {
 444 #ifdef OSG_DEBUG_LOCK_STAT
 445         _pLockStats[i] = 0;
 446 #endif
 447         sprintf(pTmp, "%s%u\n", _szName, i);
 448
 449         osgStringDup(pTmp, _pLocks[i]._szName);
 450
 451         returnValue &= _pLocks[i].init();
 452     }
 453
 454     delete [] pTmp;
 455
 456     return returnValue;
 457 }
 458
 459 /*--------------------------- Destruction ---------------------------------*/
 460
 461 void LockPool::shutdown(void)
 462 {
 463 }
 464