Source/Base/Threading/OSGCondVar.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 // If we are on windows and not WinCE, then target Windows NT 4.0
  43 #if defined (WIN32) && !defined(_WIN32_WINNT) && !defined(_WIN32_WCE)
  44 #define _WIN32_WINNT 0x0400
  45 #endif
  46
  47 #include "OSGConfig.h"
  48
  49 #include <iostream>
  50
  51 #include "OSGCondVar.h"
  52
  53 #include "OSGBaseFunctions.h"
  54
  55 #include "OSGThreadManager.h"
  56
  57 #include "OSGLog.h"
  58
  59 OSG_USING_NAMESPACE
  60
  61 //---------------------------------------------------------------------------
  62 //  Class
  63 //---------------------------------------------------------------------------
  64
  65 /*--------------------------- Constructors --------------------------------*/
  66
  67 CondVarCommonBase::CondVarCommonBase(void) :
  68      Inherited  (NULL, true),
  69     _uiCondVarId(0         )
  70 {
  71 }
  72
  73 CondVarCommonBase::CondVarCommonBase(const Char8  *szName,
  74                                            UInt32  uiId,
  75                                            bool    bGlobal):
  76      Inherited  (szName,
  77                  bGlobal),
  78     _uiCondVarId(uiId   )
  79 {
  80 }
  81
  82 /*---------------------------- Destructor ---------------------------------*/
  83
  84 CondVarCommonBase::~CondVarCommonBase(void)
  85 {
  86 }
  87
  88
  89
  90 #if defined (OSG_USE_PTHREADS)
  91
  92 //---------------------------------------------------------------------------
  93 //  Class
  94 //---------------------------------------------------------------------------
  95
  96 /*--------------------------- Constructors --------------------------------*/
  97
  98 PThreadCondVarBase::PThreadCondVarBase(void):
  99      Inherited       (),
 100     _pLowLevelLock   (),
 101     _pLowLevelCondVar()
 102 {
 103 }
 104
 105 PThreadCondVarBase::PThreadCondVarBase(const Char8  *szName,
 106                                              UInt32  uiId,
 107                                              bool    bGlobal) :
 108      Inherited       (szName,
 109                       uiId,
 110                       bGlobal),
 111     _pLowLevelLock   (       ),
 112     _pLowLevelCondVar(       )
 113 {
 114 }
 115
 116 /*---------------------------- Destructor ---------------------------------*/
 117
 118 PThreadCondVarBase::~PThreadCondVarBase(void)
 119 {
 120 }
 121
 122 /*--------------------------- Construction --------------------------------*/
 123
 124 bool PThreadCondVarBase::init(void)
 125 {
 126     pthread_mutexattr_t lockAttr;
 127
 128     pthread_mutexattr_init(&lockAttr);
 129
 130     pthread_mutexattr_settype(&lockAttr, PTHREAD_MUTEX_RECURSIVE);
 131
 132     pthread_mutex_init(&(_pLowLevelLock), &lockAttr);
 133
 134     // Initialize the condition variable.
 135     pthread_cond_init(&(_pLowLevelCondVar), NULL);
 136
 137     return true;
 138 }
 139
 140 /*--------------------------- Destruction ---------------------------------*/
 141
 142 void PThreadCondVarBase::shutdown(void)
 143 {
 144     pthread_mutex_destroy(&(_pLowLevelLock));
 145     pthread_cond_destroy(&(_pLowLevelCondVar));
 146 }
 147
 148 bool PThreadCondVarBase::wait(const Int32 timeToWait)
 149 {
 150     bool result(true);
 151
 152     // Wait indefinitely on the condition variable.
 153     if(timeToWait < 0)
 154     {
 155          const int retcode = pthread_cond_wait(&(_pLowLevelCondVar), &(_pLowLevelLock));
 156
 157          // If pthread_cond_wait(3) returned non-zero status, then we throw
 158          // an exception. Otherwise, we return true.
 159          if(retcode != 0)
 160          {
 161              return false;
 162          }
 163     }
 164     // Wait for no longer than the given timeout period to acquire the lock
 165     // on the condition variable.
 166     else
 167     {
 168         struct timeval  now;                // The current time
 169         struct timespec abs_timeout;        // The absolute time of the timeout
 170
 171         const UInt64 UsecsPerSec(1000000);
 172
 173         // Calculate the absolute time for wait timeout
 174         gettimeofday(&now, NULL);
 175
 176         UInt64 abs_secs = now.tv_sec +
 177             static_cast<long> (timeToWait / 1000);
 178         UInt64 abs_usecs = now.tv_usec +
 179             static_cast<long>((timeToWait % 1000) * 1000);
 180
 181         if(abs_usecs > UsecsPerSec)    // Have extra seconds
 182         {
 183             abs_secs += abs_usecs / UsecsPerSec;    // Get the number of seconds
 184             abs_usecs = abs_usecs % UsecsPerSec;
 185         }
 186
 187         abs_timeout.tv_sec = abs_secs;
 188         abs_timeout.tv_nsec = 1000 * (abs_usecs);
 189         OSG_ASSERT(abs_timeout.tv_nsec < Int64(UsecsPerSec * 1000) &&
 190                    "Nano seconds out of range (greater then one second).");
 191
 192         const int retcode = pthread_cond_timedwait(&(_pLowLevelCondVar),
 193                                                    &(_pLowLevelLock),
 194                                                    &abs_timeout);
 195
 196         // Successful completion: return true.
 197         if( 0 == retcode )
 198         {
 199             result = true;
 200         }
 201         else
 202         {
 203             result = false;
 204         }
 205     }
 206
 207     return result;
 208 }
 209
 210
 211 #endif /* OSG_USE_PTHREADS */
 212
 213
 214 #if defined (OSG_USE_SPROC)
 215
 216 //---------------------------------------------------------------------------
 217 //  Class
 218 //---------------------------------------------------------------------------
 219
 220 /*--------------------------- Constructors --------------------------------*/
 221
 222 SprocCondVarBase::SprocCondVarBase(void):
 223      Inherited    (    ),
 224 #ifdef OSG_SPROC_USE_LOCK
 225     _pLowLevelLock(NULL)
 226 #else
 227     _pLowLevelSema(NULL)
 228 #endif
 229 {
 230 }
 231
 232 SprocCondVarBase::SprocCondVarBase(const Char8  *szName,
 233                                    UInt32  uiId  ):
 234      Inherited    (szName, uiId),
 235     _pLowLevelLock(NULL        )
 236 #ifdef OSG_SPROC_USE_LOCK
 237     _pLowLevelLock(NULL        )
 238 #else
 239     _pLowLevelSema(NULL        )
 240 #endif
 241 {
 242 }
 243
 244 /*---------------------------- Destructor ---------------------------------*/
 245
 246 SprocCondVarBase::~SprocCondVarBase(void)
 247 {
 248 }
 249
 250 /*--------------------------- Construction --------------------------------*/
 251
 252 bool SprocCondVarBase::init(void)
 253 {
 254     ThreadManager *pThreadManager = ThreadManager::the();
 255
 256     if(pThreadManager == NULL)
 257         return false;
 258
 259     if(pThreadManager->getArena() == NULL)
 260         return false;
 261
 262 #ifdef OSG_SPROC_USE_LOCK
 263     _pLowLevelLock = usnewlock(pThreadManager->getArena());
 264
 265     if(_pLowLevelLock == NULL)
 266         return false;
 267
 268     usinitlock(_pLowLevelLock);
 269
 270 #else
 271     _pLowLevelSema = usnewsema(pThreadManager->getArena(), 1);
 272
 273     if(_pLowLevelSema == NULL)
 274         return false;
 275
 276     usinitsema(_pLowLevelSema, 1);
 277     usctlsema (_pLowLevelSema, CS_RECURSIVEON, NULL);
 278 #endif
 279
 280     return true;
 281 }
 282
 283 /*--------------------------- Destruction ---------------------------------*/
 284
 285 void SprocCondVarBase::shutdown(void)
 286 {
 287     ThreadManager *pThreadManager = ThreadManager::the();
 288
 289     if(pThreadManager == NULL)
 290         return;
 291
 292     if(pThreadManager->getArena() == NULL)
 293         return;
 294
 295 #ifdef OSG_SPROC_USE_LOCK
 296     if(_pLowLevelLock != NULL)
 297     {
 298         usfreelock(_pLowLevelLock, pThreadManager->getArena());
 299
 300         _pLowLevelLock = NULL;
 301     }
 302 #else
 303     if(_pLowLevelSema != NULL)
 304     {
 305         usfreesema(_pLowLevelSema, pThreadManager->getArena());
 306
 307         _pLowLevelSema = NULL;
 308     }
 309 #endif
 310 }
 311
 312 /*------------------------------- CondVar ---------------------------------*/
 313
 314 #endif /* OSG_USE_SPROC */
 315
 316
 317
 318 #if defined (OSG_USE_WINTHREADS)
 319
 320 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 321
 322 int pthread_cond_init(pthread_cond_t *cv, void *dummy)
 323 {
 324     cv->waiters_count_ = 0;
 325     cv->was_broadcast_ = 0;
 326     cv->sema_ = CreateSemaphore(NULL,       // no security
 327                                  0,          // initially 0
 328                                  0x7fffffff, // max count
 329                                  NULL);      // unnamed
 330     InitializeCriticalSection(&cv->waiters_count_lock_);
 331     cv->waiters_done_ = CreateEvent (NULL,  // no security
 332                                      FALSE, // auto-reset
 333                                      FALSE, // non-signaled initially
 334                                      NULL); // unnamed
 335     return 0;
 336 }
 337
 338 int pthread_cond_wait(pthread_cond_t *cv,
 339                       pthread_mutex_t *external_mutex)
 340 {
 341     // Avoid race conditions.
 342     EnterCriticalSection(&cv->waiters_count_lock_);
 343     cv->waiters_count_++;
 344     LeaveCriticalSection(&cv->waiters_count_lock_);
 345
 346     // This call atomically releases the mutex and waits on the
 347     // semaphore until <pthread_cond_signal> or <pthread_cond_broadcast>
 348     // are called by another thread.
 349     ::SignalObjectAndWait(*external_mutex, cv->sema_, INFINITE, FALSE);
 350
 351     // Reacquire lock to avoid race conditions.
 352     EnterCriticalSection(&cv->waiters_count_lock_);
 353
 354     // We're no longer waiting...
 355     cv->waiters_count_--;
 356
 357     // Check to see if we're the last waiter after <pthread_cond_broadcast>.
 358     int last_waiter = cv->was_broadcast_ && cv->waiters_count_ == 0;
 359
 360     LeaveCriticalSection(&cv->waiters_count_lock_);
 361
 362     // If we're the last waiter thread during this particular broadcast
 363     // then let all the other threads proceed.
 364     if(last_waiter)
 365     {
 366         // This call atomically signals the <waiters_done_> event and waits until
 367         // it can acquire the <external_mutex>.  This is required to ensure fairness.
 368         ::SignalObjectAndWait(cv->waiters_done_, *external_mutex, INFINITE, FALSE);
 369     }
 370     else
 371     {
 372         // Always regain the external mutex since that's the guarantee we
 373         // give to our callers.
 374         //WaitForSingleObject (*external_mutex);
 375         WaitForSingleObject(cv->waiters_done_, INFINITE);
 376     }
 377
 378     return 0;
 379 }
 380
 381 int pthread_cond_signal(pthread_cond_t *cv)
 382 {
 383     EnterCriticalSection(&cv->waiters_count_lock_);
 384     int have_waiters = cv->waiters_count_ > 0;
 385     LeaveCriticalSection(&cv->waiters_count_lock_);
 386
 387     // If there aren't any waiters, then this is a no-op.
 388     if(have_waiters)
 389     {
 390         ReleaseSemaphore(cv->sema_, 1, 0);
 391     }
 392     return 0;
 393 }
 394
 395 int pthread_cond_broadcast (pthread_cond_t *cv)
 396 {
 397     // This is needed to ensure that <waiters_count_> and <was_broadcast_> are
 398     // consistent relative to each other.
 399     EnterCriticalSection(&cv->waiters_count_lock_);
 400     int have_waiters = 0;
 401
 402     if(cv->waiters_count_ > 0)
 403     {
 404         // We are broadcasting, even if there is just one waiter...
 405         // Record that we are broadcasting, which helps optimize
 406         // <pthread_cond_wait> for the non-broadcast case.
 407         cv->was_broadcast_ = 1;
 408         have_waiters = 1;
 409     }
 410
 411     if(have_waiters)
 412     {
 413         // Wake up all the waiters atomically.
 414         ReleaseSemaphore(cv->sema_, cv->waiters_count_, 0);
 415
 416         LeaveCriticalSection(&cv->waiters_count_lock_);
 417
 418         // Wait for all the awakened threads to acquire the counting
 419         // semaphore.
 420         WaitForSingleObject(cv->waiters_done_, INFINITE);
 421         // This assignment is okay, even without the <waiters_count_lock_> held
 422         // because no other waiter threads can wake up to access it.
 423         cv->was_broadcast_ = 0;
 424     }
 425     else
 426     {
 427         LeaveCriticalSection(&cv->waiters_count_lock_);
 428     }
 429
 430   return 0;
 431 }
 432
 433 #endif
 434
 435 //---------------------------------------------------------------------------
 436 //  Class
 437 //---------------------------------------------------------------------------
 438
 439 /*--------------------------- Constructors --------------------------------*/
 440
 441 WinThreadCondVarBase::WinThreadCondVarBase(void) :
 442        Inherited(    )
 443     , _pMutex   (NULL)
 444 {
 445 }
 446
 447 WinThreadCondVarBase::WinThreadCondVarBase(const Char8  *szName,
 448                                                  UInt32  uiId,
 449                                                  bool    bGlobal) :
 450      Inherited(szName, uiId, bGlobal),
 451     _pMutex   (NULL                 )
 452 {
 453 }
 454
 455 /*---------------------------- Destructor ---------------------------------*/
 456
 457 WinThreadCondVarBase::~WinThreadCondVarBase(void)
 458 {
 459 }
 460
 461 /*-------------------------- Construction ---------------------------------*/
 462
 463 bool WinThreadCondVarBase::init(void)
 464 {
 465 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 466     _pMutex = CreateMutex(NULL,     // no security attributes
 467                           FALSE,    // initially not owned
 468                           _szName);  // name of mutex
 469
 470     if(_pMutex == NULL)
 471     {
 472         return false;
 473     }
 474
 475     waiters_count_ = 0;
 476     was_broadcast_ = 0;
 477     sema_ = CreateSemaphore(NULL,       // no security
 478                             0,          // initially 0
 479                             0x7fffffff, // max count
 480                             NULL);      // unnamed
 481     InitializeCriticalSection(&waiters_count_lock_);
 482     waiters_done_ = CreateEvent(NULL,  // no security
 483                                 FALSE, // auto-reset
 484                                 FALSE, // non-signaled initially
 485                                 NULL); // unnamed
 486     return true;
 487 #else
 488     OSG_ASSERT(false && "CondVar::init() Not implemented for versions of Windows < 4.0");
 489     return false;
 490 #endif
 491 }
 492
 493 bool WinThreadCondVarBase::wait(const Int32 timeToWait)
 494 {
 495 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 496     // Avoid race conditions.
 497     EnterCriticalSection (&waiters_count_lock_);
 498     waiters_count_++;
 499     LeaveCriticalSection (&waiters_count_lock_);
 500
 501     // This call atomically releases the mutex and waits on the
 502     // semaphore until <pthread_cond_signal> or <pthread_cond_broadcast>
 503     // are called by another thread.
 504     SignalObjectAndWait(_pMutex, sema_, INFINITE, FALSE);
 505
 506     // Reacquire lock to avoid race conditions.
 507     EnterCriticalSection(&waiters_count_lock_);
 508
 509     // We're no longer waiting...
 510     waiters_count_--;
 511
 512     // Check to see if we're the last waiter after <pthread_cond_broadcast>.
 513     int last_waiter = was_broadcast_ && waiters_count_ == 0;
 514
 515     LeaveCriticalSection(&waiters_count_lock_);
 516
 517     // XXX: Need to use timeToWait.
 518
 519     // If we're the last waiter thread during this particular broadcast
 520     // then let all the other threads proceed.
 521     if(last_waiter)
 522     {
 523         // This call atomically signals the <waiters_done_> event and waits until
 524         // it can acquire the <external_mutex>.  This is required to ensure fairness.
 525         SignalObjectAndWait(waiters_done_, _pMutex, INFINITE, FALSE);
 526     }
 527     else
 528     {
 529         // Always regain the external mutex since that's the guarantee we
 530         // give to our callers.
 531         WaitForSingleObject(_pMutex, INFINITE);
 532     }
 533 #else
 534     OSG_ASSERT(false && "CondVar::wait() Not implemented for versions of Windows < 4.0");
 535 #endif
 536     return 0;
 537 }
 538
 539 void WinThreadCondVarBase::signal()
 540 {
 541 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 542     EnterCriticalSection(&waiters_count_lock_);
 543     int have_waiters = waiters_count_ > 0;
 544     LeaveCriticalSection(&waiters_count_lock_);
 545
 546     // If there aren't any waiters, then this is a no-op.
 547     if(have_waiters)
 548     {
 549         ReleaseSemaphore(sema_, 1, 0);
 550     }
 551 #else
 552     OSG_ASSERT(false && "CondVar::signal() Not implemented for versions of Windows < 4.0");
 553 #endif
 554 }
 555
 556 void WinThreadCondVarBase::broadcast()
 557 {
 558 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 559     // This is needed to ensure that <waiters_count_> and <was_broadcast_> are
 560     // consistent relative to each other.
 561     EnterCriticalSection(&waiters_count_lock_);
 562     int have_waiters = 0;
 563
 564     if(waiters_count_ > 0)
 565     {
 566         // We are broadcasting, even if there is just one waiter...
 567         // Record that we are broadcasting, which helps optimize
 568         // <pthread_cond_wait> for the non-broadcast case.
 569         was_broadcast_ = 1;
 570         have_waiters = 1;
 571     }
 572
 573     if(have_waiters)
 574     {
 575         // Wake up all the waiters atomically.
 576         ReleaseSemaphore(sema_, waiters_count_, 0);
 577
 578         LeaveCriticalSection(&waiters_count_lock_);
 579
 580         // Wait for all the awakened threads to acquire the counting
 581         // semaphore.
 582         WaitForSingleObject(waiters_done_, INFINITE);
 583         // This assignment is okay, even without the <waiters_count_lock_> held
 584         // because no other waiter threads can wake up to access it.
 585         was_broadcast_ = 0;
 586     }
 587     else
 588     {
 589         LeaveCriticalSection(&waiters_count_lock_);
 590     }
 591 #else
 592     OSG_ASSERT(false && "CondVar::broadcast() Not implemented for versions of Windows < 4.0");
 593 #endif
 594 }
 595
 596 /*-------------------------- Destruction ----------------------------------*/
 597
 598 void WinThreadCondVarBase::shutdown(void)
 599 {
 600 #if defined _WIN32_WINNT && _WIN32_WINNT >= 0x0400
 601     if(_pMutex != NULL)
 602     {
 603         CloseHandle(_pMutex);
 604     }
 605     if(sema_ != NULL)
 606     {
 607         CloseHandle(sema_);
 608     }
 609     DeleteCriticalSection(&waiters_count_lock_);
 610     if(waiters_done_ != NULL)
 611     {
 612         CloseHandle(waiters_done_);
 613     }
 614 #else
 615     OSG_ASSERT(false && "CondVar::shutdown() Not implemented for versions of Windows < 4.0");
 616 #endif
 617 }
 618
 619 #endif /* OSG_USE_WINTHREADS */
 620
 621
 622
 623 //---------------------------------------------------------------------------
 624 //  Class
 625 //---------------------------------------------------------------------------
 626
 627 MPCondVarType CondVar::_type("OSGCondVar", "OSGMPBase", &CondVar::create);
 628
 629 /*------------------------------- Get -------------------------------------*/
 630
 631 CondVar::ObjTransitPtr CondVar::get(const Char8 *szName, bool bGlobal)
 632 {
 633     return ThreadManager::the()->getCondVar(szName, bGlobal, "OSGCondVar");
 634 }
 635
 636 CondVar *CondVar::find(const Char8 *szName)
 637 {
 638     return ThreadManager::the()->findCondVar(szName);
 639 }
 640
 641
 642 /*------------------------------ Create -----------------------------------*/
 643
 644 CondVar *CondVar::create(const Char8 *szName, UInt32 uiId, bool bGlobal)
 645 {
 646     CondVar *returnValue = NULL;
 647
 648     returnValue = new CondVar(szName, uiId, bGlobal);
 649
 650     if(returnValue->init() == false)
 651     {
 652         delete returnValue;
 653         returnValue = NULL;
 654     }
 655
 656     return returnValue;
 657 }
 658
 659 /*--------------------------- Constructors --------------------------------*/
 660
 661 CondVar::CondVar(void) :
 662     Inherited()
 663 {
 664 }
 665
 666 CondVar::CondVar(const Char8 *szName, UInt32 uiId, bool bGlobal) :
 667     Inherited(szName, uiId, bGlobal)
 668 {
 669 }
 670
 671 /*---------------------------- Destructor ---------------------------------*/
 672
 673 CondVar::~CondVar(void)
 674 {
 675     _bGlobal = false;
 676
 677     ThreadManager::the()->remove(this);
 678
 679     shutdown();
 680 }