Source/Base/Threading/OSGLock.h

   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 #ifndef _OSGLOCK_H_
  40 #define _OSGLOCK_H_
  41 #ifdef __sgi
  42 #pragma once
  43 #endif
  44
  45 #include "OSGBaseTypes.h"
  46 #include "OSGMPBase.h"
  47
  48 #if ! defined (OSG_USE_PTHREADS)   && \
  49     ! defined (OSG_USE_SPROC)      && \
  50     ! defined (OSG_USE_WINTHREADS)
  51 #error "No threading model defined,  check your system/compiler combination"
  52 #endif
  53
  54 #if defined (OSG_USE_PTHREADS)
  55 #include <pthread.h>
  56 #include <cerrno>
  57 #endif
  58
  59 #if defined (OSG_USE_SPROC)
  60 #include <ulocks.h>
  61 #endif
  62
  63 #include <boost/mpl/if.hpp>
  64
  65 OSG_BEGIN_NAMESPACE
  66
  67 static const UInt32 uiLockPoolSize = 32;
  68
  69 template <class MPFieldT>
  70 class MPFieldStore;
  71
  72 //---------------------------------------------------------------------------
  73 //  Class
  74 //---------------------------------------------------------------------------
  75
  76 /*! \ingroup GrpBaseMultiThreading
  77     \ingroup GrpLibOSGBase
  78  */
  79
  80 class OSG_BASE_DLLMAPPING LockCommonBase : public MPBase
  81 {
  82     /*==========================  PUBLIC  =================================*/
  83
  84   public:
  85
  86     /*=========================  PROTECTED  ===============================*/
  87
  88   protected:
  89
  90     typedef MPBase  Inherited;
  91
  92             UInt32 _uiLockId;
  93
  94     /*---------------------------------------------------------------------*/
  95     /*! \name                   Constructors                               */
  96     /*! \{                                                                 */
  97
  98     LockCommonBase(void);
  99     LockCommonBase(const Char8 *szName, UInt32 uiId, bool bGlobal);
 100
 101     /*! \}                                                                 */
 102     /*---------------------------------------------------------------------*/
 103     /*! \name                   Destructor                                 */
 104     /*! \{                                                                 */
 105
 106     virtual ~LockCommonBase(void);
 107
 108     /*! \}                                                                 */
 109     /*==========================  PRIVATE  ================================*/
 110
 111   private:
 112
 113     /*!\brief prohibit default function (move to 'public' if needed) */
 114     LockCommonBase  (const LockCommonBase &source);
 115     /*!\brief prohibit default function (move to 'public' if needed) */
 116     void operator = (const LockCommonBase &source);
 117 };
 118
 119
 120
 121
 122 //---------------------------------------------------------------------------
 123 //  Class
 124 //---------------------------------------------------------------------------
 125
 126 #if defined (OSG_USE_PTHREADS)
 127
 128 /*! \ingroup GrpBaseMultiThreading
 129     \ingroup GrpLibOSGBase
 130  */
 131
 132 class PThreadLockBase : public LockCommonBase
 133 {
 134     /*==========================  PUBLIC  =================================*/
 135
 136   public :
 137
 138     /*=========================  PROTECTED  ===============================*/
 139
 140   protected:
 141
 142     typedef LockCommonBase Inherited;
 143
 144     /*---------------------------------------------------------------------*/
 145     /*! \name                   Constructors                               */
 146     /*! \{                                                                 */
 147
 148     PThreadLockBase(void);
 149     PThreadLockBase(const Char8 *szName, UInt32 uiId, bool bGlobal);
 150
 151     /*! \}                                                                 */
 152     /*---------------------------------------------------------------------*/
 153     /*! \name                   Destructor                                 */
 154     /*! \{                                                                 */
 155
 156     virtual ~PThreadLockBase(void);
 157
 158     /*! \}                                                                 */
 159     /*---------------------------------------------------------------------*/
 160     /*! \name                  Construction                                */
 161     /*! \{                                                                 */
 162
 163     bool init    (void);
 164
 165     /*! \}                                                                 */
 166     /*---------------------------------------------------------------------*/
 167     /*! \name                  Destruction                                 */
 168     /*! \{                                                                 */
 169
 170     void shutdown(void);
 171
 172     /*! \}                                                                 */
 173     /*---------------------------------------------------------------------*/
 174     /*! \name                   Lock                                       */
 175     /*! \{                                                                 */
 176
 177     void acquire(void);
 178     void release(void);
 179     bool request(void);
 180
 181     /*! \}                                                                 */
 182     /*==========================  PRIVATE  ================================*/
 183
 184   private:
 185
 186     friend class LockPool;
 187
 188     pthread_mutex_t _pLowLevelLock;
 189
 190     /*!\brief prohibit default function (move to 'public' if needed) */
 191     PThreadLockBase(const PThreadLockBase &source);
 192     /*!\brief prohibit default function (move to 'public' if needed) */
 193     void operator =(const PThreadLockBase &source);
 194 };
 195
 196 typedef PThreadLockBase LockBase;
 197
 198 #endif /* OSG_USE_PTHREADS */
 199
 200
 201
 202
 203 //---------------------------------------------------------------------------
 204 //  Class
 205 //---------------------------------------------------------------------------
 206
 207 #if defined (OSG_USE_SPROC)
 208
 209 /*! \ingroup GrpBaseMultiThreading
 210     \ingroup GrpLibOSGBase
 211  */
 212
 213 class SprocLockBase : public LockCommonBase
 214 {
 215     /*==========================  PUBLIC  =================================*/
 216
 217   public :
 218
 219     /*=========================  PROTECTED  ===============================*/
 220
 221   protected:
 222
 223     typedef LockCommonBase Inherited;
 224
 225     /*---------------------------------------------------------------------*/
 226     /*! \name                   Constructors                               */
 227     /*! \{                                                                 */
 228
 229     SprocLockBase(void);
 230     SprocLockBase(const Char8 *szName, UInt32 uiId, bool bGlobal);
 231
 232     /*! \}                                                                 */
 233     /*---------------------------------------------------------------------*/
 234     /*! \name                   Destructor                                 */
 235     /*! \{                                                                 */
 236
 237     virtual ~SprocLockBase(void);
 238
 239     /*! \}                                                                 */
 240     /*---------------------------------------------------------------------*/
 241     /*! \name                   Construction                               */
 242     /*! \{                                                                 */
 243
 244     bool init    (void);
 245
 246     /*! \}                                                                 */
 247     /*---------------------------------------------------------------------*/
 248     /*! \name                   Destruction                                */
 249     /*! \{                                                                 */
 250
 251     void shutdown(void);
 252
 253     /*! \}                                                                 */
 254     /*---------------------------------------------------------------------*/
 255     /*! \name                    Lock                                      */
 256     /*! \{                                                                 */
 257
 258     void acquire(void);
 259     void release(void);
 260     bool request(void);
 261
 262     /*! \}                                                                 */
 263     /*==========================  PRIVATE  ================================*/
 264
 265   private:
 266
 267     friend class LockPool;
 268
 269 #define OSG_SPROC_USE_LOCK
 270 #ifdef OSG_SPROC_USE_LOCK
 271     ulock_t  _pLowLevelLock;
 272 #else
 273     usema_t *_pLowLevelSema;
 274 #endif
 275
 276     /*!\brief prohibit default function (move to 'public' if needed) */
 277     SprocLockBase(const SprocLockBase &source);
 278     /*!\brief prohibit default function (move to 'public' if needed) */
 279     void operator =(const SprocLockBase &source);
 280 };
 281
 282 typedef SprocLockBase LockBase;
 283
 284 #endif /* OSG_USE_SPROC */
 285
 286
 287
 288
 289 //---------------------------------------------------------------------------
 290 //  Class
 291 //---------------------------------------------------------------------------
 292
 293 #if defined (OSG_USE_WINTHREADS)
 294
 295 #if _WIN32_WINNT < 0x0400
 296 #define OSG_WINLOCK_USE_MUTEX
 297 #endif
 298
 299 /*! \ingroup GrpBaseMultiThreading
 300     \ingroup GrpLibOSGBase
 301  */
 302
 303 class OSG_BASE_DLLMAPPING WinThreadLockBase : public LockCommonBase
 304 {
 305     /*==========================  PUBLIC  =================================*/
 306
 307   public :
 308
 309     /*=========================  PROTECTED  ===============================*/
 310
 311   protected:
 312
 313     typedef LockCommonBase Inherited;
 314
 315     /*---------------------------------------------------------------------*/
 316     /*! \name                   Constructors                               */
 317     /*! \{                                                                 */
 318
 319     WinThreadLockBase(void);
 320     WinThreadLockBase(const Char8 *szName, UInt32 uiId, bool bGlobal);
 321
 322     /*! \}                                                                 */
 323     /*---------------------------------------------------------------------*/
 324     /*! \name                   Destructor                                 */
 325     /*! \{                                                                 */
 326
 327     virtual ~WinThreadLockBase(void);
 328
 329     /*! \}                                                                 */
 330     /*---------------------------------------------------------------------*/
 331     /*! \name                   Construction                               */
 332     /*! \{                                                                 */
 333
 334     bool init    (void);
 335
 336     /*! \}                                                                 */
 337     /*---------------------------------------------------------------------*/
 338     /*! \name                   Destruction                                */
 339     /*! \{                                                                 */
 340
 341     void shutdown(void);
 342
 343     /*! \}                                                                 */
 344     /*---------------------------------------------------------------------*/
 345     /*! \name                       Lock                                   */
 346     /*! \{                                                                 */
 347
 348     void acquire(void);
 349     void release(void);
 350     bool request(void);
 351
 352     /*! \}                                                                 */
 353     /*==========================  PRIVATE  ================================*/
 354   private:
 355
 356     friend class LockPool;
 357
 358 #ifdef OSG_WINLOCK_USE_MUTEX
 359     Handle  _pMutex;
 360 #else
 361     CRITICAL_SECTION _pCriticalSection;
 362 #endif
 363
 364     /*!\brief prohibit default function (move to 'public' if needed) */
 365     WinThreadLockBase(const WinThreadLockBase &source);
 366     /*!\brief prohibit default function (move to 'public' if needed) */
 367     void operator =(const WinThreadLockBase &source);
 368 };
 369
 370 typedef WinThreadLockBase LockBase;
 371
 372 #endif /* OSG_USE_WINTHREADS */
 373
 374
 375
 376
 377 //---------------------------------------------------------------------------
 378 //  Class
 379 //---------------------------------------------------------------------------
 380
 381 /*! \ingroup GrpBaseMultiThreading
 382     \ingroup GrpLibOSGBase
 383  */
 384
 385 class OSG_BASE_DLLMAPPING Lock : public LockBase
 386 {
 387     /*==========================  PUBLIC  =================================*/
 388
 389   public:
 390
 391     typedef MPLockType Type;
 392
 393     OSG_GEN_INTERNAL_MEMOBJPTR(Lock);
 394
 395     /*---------------------------------------------------------------------*/
 396     /*! \name                      Get                                     */
 397     /*! \{                                                                 */
 398
 399     static       ObjTransitPtr  get         (const Char8 *szName,
 400                                                    bool   bGlobal);
 401     static       Lock          *find        (const Char8 *szName );
 402
 403     static       ObjTransitPtr  create      (      void          );
 404
 405     static const MPLockType    &getClassType(      void          );
 406
 407     /*! \}                                                                 */
 408     /*---------------------------------------------------------------------*/
 409     /*! \name                       Lock                                   */
 410     /*! \{                                                                 */
 411
 412     void acquire(void);
 413     void release(void);
 414     bool request(void);
 415
 416     /*! \}                                                                 */
 417     /*=========================  PROTECTED  ===============================*/
 418
 419   protected:
 420
 421     typedef LockBase    Inherited;
 422
 423     static  MPLockType _type;
 424
 425     /*---------------------------------------------------------------------*/
 426     /*! \name                   Construction                               */
 427     /*! \{                                                                 */
 428
 429     static Lock *create(const Char8 *szName, UInt32 uiId, bool bGlobal);
 430
 431     /*! \}                                                                 */
 432     /*---------------------------------------------------------------------*/
 433     /*! \name                   Constructors                               */
 434     /*! \{                                                                 */
 435
 436     Lock(void);
 437     Lock(const Char8 *szName, UInt32 uiId, bool bGlobal);
 438
 439     /*! \}                                                                 */
 440     /*---------------------------------------------------------------------*/
 441     /*! \name                   Destructor                                 */
 442     /*! \{                                                                 */
 443
 444     virtual ~Lock(void);
 445
 446     /*! \}                                                                 */
 447     /*==========================  PRIVATE  ================================*/
 448
 449   private:
 450
 451     friend class LockPool;
 452     friend class MPFieldStore<Lock>;
 453
 454     /*!\brief prohibit default function (move to 'public' if needed) */
 455     Lock(const Lock &source);
 456     /*!\brief prohibit default function (move to 'public' if needed) */
 457     void operator =(const Lock &source);
 458 };
 459
 460 OSG_GEN_MEMOBJPTR(Lock);
 461
 462
 463
 464 //---------------------------------------------------------------------------
 465 //  Class
 466 //---------------------------------------------------------------------------
 467
 468 /*! \ingroup GrpBaseMultiThreading
 469     \ingroup GrpLibOSGBase
 470  */
 471
 472 class OSG_BASE_DLLMAPPING LockPool : public LockCommonBase
 473 {
 474     /*==========================  PUBLIC  =================================*/
 475
 476   public:
 477
 478     typedef MPLockPoolType Type;
 479
 480     OSG_GEN_INTERNAL_MEMOBJPTR(LockPool);
 481
 482     /*---------------------------------------------------------------------*/
 483     /*! \name                      Get                                     */
 484     /*! \{                                                                 */
 485
 486     static       ObjTransitPtr   get         (const Char8 *szName,
 487                                                     bool   bGlobal);
 488     static       LockPool       *find        (const Char8 *szName );
 489     static       ObjTransitPtr   create      (      void          );
 490     static const MPLockPoolType &getClassType(      void          );
 491
 492     /*! \}                                                                 */
 493     /*---------------------------------------------------------------------*/
 494     /*! \name                   Lock                                       */
 495     /*! \{                                                                 */
 496
 497     void acquire(void *keyP);
 498     void release(void *keyP);
 499     bool request(void *keyP);
 500
 501     /*! \}                                                                 */
 502     /*=========================  PROTECTED  ===============================*/
 503
 504   protected:
 505
 506     typedef LockCommonBase  Inherited;
 507
 508     static  MPLockPoolType _type;
 509
 510             Lock           _pLocks    [uiLockPoolSize];
 511
 512 #ifdef OSG_DEBUG_LOCK_STAT
 513             UInt32         _pLockStats[uiLockPoolSize];
 514 #endif
 515
 516     /*! \nohierarchy
 517      */
 518
 519     struct ErrorCouldNotMatchSize {};
 520
 521     typedef
 522         boost::mpl::if_<boost::mpl::bool_<(sizeof(void *) == sizeof(UInt32))>,
 523                         UInt32,
 524                         ErrorCouldNotMatchSize>::type NumericalKeyType32;
 525
 526     typedef
 527         boost::mpl::if_<boost::mpl::bool_<(sizeof(void *) == sizeof(UInt64))>,
 528                         UInt64,
 529                         NumericalKeyType32>::type NumericalKeyType;
 530
 531     /*---------------------------------------------------------------------*/
 532     /*! \name                      Create                                  */
 533     /*! \{                                                                 */
 534
 535     /*! \}                                                                 */
 536     /*---------------------------------------------------------------------*/
 537     /*! \name                   Constructor                                */
 538     /*! \{                                                                 */
 539
 540     static const NumericalKeyType uiLockPoolMask = 0x0f80;
 541
 542     static LockPool *create(const Char8 *szName, UInt32 uiId, bool bGlobal);
 543
 544     /*! \}                                                                 */
 545     /*---------------------------------------------------------------------*/
 546     /*! \name                   Constructor                                */
 547     /*! \{                                                                 */
 548
 549     LockPool(const Char8 *szName, UInt32 uiId, bool bGlobal);
 550
 551     /*! \}                                                                 */
 552     /*---------------------------------------------------------------------*/
 553     /*! \name                   Destructor                                 */
 554     /*! \{                                                                 */
 555
 556     virtual ~LockPool(void);
 557
 558     /*! \}                                                                 */
 559     /*---------------------------------------------------------------------*/
 560     /*! \name                   Construction                               */
 561     /*! \{                                                                 */
 562
 563     bool init(void);
 564
 565     /*! \}                                                                 */
 566     /*---------------------------------------------------------------------*/
 567     /*! \name                   Destruction                                */
 568     /*! \{                                                                 */
 569
 570     void shutdown(void);
 571
 572     /*! \}                                                                 */
 573     /*==========================  PRIVATE  ================================*/
 574
 575   private:
 576
 577     friend class MPFieldStore<LockPool>;
 578
 579     /*!\brief prohibit default function (move to 'public' if needed) */
 580     LockPool(const LockPool &source);
 581     /*!\brief prohibit default function (move to 'public' if needed) */
 582     void operator =(const LockPool &source);
 583 };
 584
 585 OSG_GEN_MEMOBJPTR(LockPool);
 586
 587 OSG_END_NAMESPACE
 588
 589 #include "OSGLock.inl"
 590
 591 #endif /* _OSGLOCK_H_ */