Source/Base/Threading/OSGThreadManager.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 #if defined(OSG_USE_SPROC)
  45 #include <cerrno>
  46 #endif
  47
  48 #include <iostream>
  49
  50 #include "OSGThreadManager.h"
  51 #include "OSGBaseInitFunctions.h"
  52
  53 #include "OSGThread.h"
  54
  55 OSG_USING_NAMESPACE
  56
  57 ThreadManager    *ThreadManager::_pThreadManager      = NULL;
  58 BaseThreadRefPtr  ThreadManager::_pAppThread          = NULL;
  59
  60 bool              ThreadManager::_bShutdownInProgress = false;
  61
  62 Char8            *ThreadManager::_szAppThreadType     = NULL;
  63
  64
  65 /*-------------------------- Get / Set ------------------------------------*/
  66
  67 void ThreadManager::setAppThreadType(const Char8 *szAppThreadType)
  68 {
  69     osgStringDup(szAppThreadType, _szAppThreadType);
  70 }
  71
  72
  73 ThreadManager *ThreadManager::the(void)
  74 {
  75     if(_pThreadManager == NULL)
  76         _pThreadManager = new ThreadManager();
  77
  78     return _pThreadManager;
  79 }
  80
  81
  82 BaseThread *ThreadManager::getAppThread(void)
  83 {
  84     return _pAppThread;
  85 }
  86
  87
  88 /*-------------------- Create Threading Elements --------------------------*/
  89
  90 BaseThreadTransitPtr ThreadManager::getThread(const Char8 *szName,
  91                                                     UInt32 bGlobal,
  92                                               const Char8 *szTypeName)
  93 {
  94     BaseThreadTransitPtr returnValue(NULL);
  95
  96     _storePLock->acquire();
  97
  98     returnValue = _sThreadStore.getMPField(szName, szTypeName, bGlobal != 0);
  99
 100     _storePLock->release();
 101
 102     return returnValue;
 103 }
 104
 105 BarrierTransitPtr ThreadManager::getBarrier(const Char8 *szName,
 106                                                   UInt32 bGlobal,
 107                                             const Char8 *szTypeName)
 108 {
 109     BarrierTransitPtr returnValue(NULL);
 110
 111     _storePLock->acquire();
 112
 113     returnValue = _sBarrierStore.getMPField(szName, szTypeName, bGlobal != 0);
 114
 115     _storePLock->release();
 116
 117     return returnValue;
 118 }
 119
 120 CondVarTransitPtr ThreadManager::getCondVar(const Char8 *szName,
 121                                                   UInt32 bGlobal,
 122                                             const Char8 *szTypeName)
 123 {
 124     CondVarTransitPtr returnValue(NULL);
 125
 126     _storePLock->acquire();
 127
 128     returnValue = _sCondVarStore.getMPField(szName, szTypeName, bGlobal != 0);
 129
 130     _storePLock->release();
 131
 132     return returnValue;
 133 }
 134
 135 LockTransitPtr ThreadManager::getLock(const Char8 *szName,
 136                                             UInt32 bGlobal,
 137                                       const Char8 *szTypeName)
 138 {
 139     LockTransitPtr returnValue(NULL);
 140
 141     _storePLock->acquire();
 142
 143     returnValue = _sLockStore.getMPField(szName, szTypeName, bGlobal != 0);
 144
 145     _storePLock->release();
 146
 147     return returnValue;
 148 }
 149
 150 LockPoolTransitPtr ThreadManager::getLockPool(const Char8 *szName,
 151                                                     UInt32 bGlobal,
 152                                               const Char8 *szTypeName)
 153 {
 154     LockPoolTransitPtr returnValue(NULL);
 155
 156     _storePLock->acquire();
 157
 158     returnValue = _sLockPoolStore.getMPField(szName, szTypeName, bGlobal != 0);
 159
 160     _storePLock->release();
 161
 162     return returnValue;
 163 }
 164
 165 SemaphoreTransitPtr ThreadManager::getSemaphore(const Char8 *szName,
 166                                                       UInt32 bGlobal,
 167                                                 const Char8 *szTypeName)
 168 {
 169     SemaphoreTransitPtr returnValue(NULL);
 170
 171     _storePLock->acquire();
 172
 173     returnValue = _sSemaphoreStore.getMPField(szName, szTypeName, bGlobal != 0);
 174
 175     _storePLock->release();
 176
 177     return returnValue;
 178 }
 179
 180 BaseThread  *ThreadManager::findThread(const Char8 *szName)
 181 {
 182     BaseThread *returnValue = NULL;
 183
 184     _storePLock->acquire();
 185
 186     returnValue = _sThreadStore.findMPField(szName);
 187
 188     _storePLock->release();
 189
 190     return returnValue;
 191 }
 192
 193 Barrier *ThreadManager::findBarrier(const Char8 *szName)
 194 {
 195     Barrier *returnValue = NULL;
 196
 197     _storePLock->acquire();
 198
 199     returnValue = _sBarrierStore.findMPField(szName);
 200
 201     _storePLock->release();
 202
 203     return returnValue;
 204 }
 205
 206 CondVar *ThreadManager::findCondVar(const Char8 *szName)
 207 {
 208     CondVar *returnValue = NULL;
 209
 210     _storePLock->acquire();
 211
 212     returnValue = _sCondVarStore.findMPField(szName);
 213
 214     _storePLock->release();
 215
 216     return returnValue;
 217 }
 218
 219 Lock *ThreadManager::findLock(const Char8 *szName)
 220 {
 221     Lock *returnValue = NULL;
 222
 223     _storePLock->acquire();
 224
 225     returnValue = _sLockStore.findMPField(szName);
 226
 227     _storePLock->release();
 228
 229     return returnValue;
 230 }
 231
 232 LockPool *ThreadManager::findLockPool(const Char8 *szName)
 233 {
 234     LockPool *returnValue = NULL;
 235
 236     _storePLock->acquire();
 237
 238     returnValue = _sLockPoolStore.findMPField(szName);
 239
 240     _storePLock->release();
 241
 242     return returnValue;
 243 }
 244
 245 Semaphore *ThreadManager::findSemaphore(const Char8 *szName)
 246 {
 247     Semaphore *returnValue = NULL;
 248
 249     _storePLock->acquire();
 250
 251     returnValue = _sSemaphoreStore.findMPField(szName);
 252
 253     _storePLock->release();
 254
 255     return returnValue;
 256 }
 257
 258 void ThreadManager::dump(void)
 259 {
 260     ThreadStore::MPFieldMapCIt tI = _sThreadStore._mFieldMap.begin();
 261     ThreadStore::MPFieldMapCIt tE = _sThreadStore._mFieldMap.end  ();
 262
 263     for(; tI != tE; ++tI)
 264     {
 265         FLOG(("ThreadManager::dump: "
 266                "thread [%s|%p] is still alive ([%d]). \n",
 267                (*tI).first.c_str(),
 268                (*tI).second,
 269                (*tI).second->exists()));
 270     }
 271
 272     BarrierStore::MPFieldMapCIt bI = _sBarrierStore._mFieldMap.begin();
 273     BarrierStore::MPFieldMapCIt bE = _sBarrierStore._mFieldMap.end  ();
 274
 275     for(; bI != bE; ++bI)
 276     {
 277         FINFO(("ThreadManager::dump: "
 278                "barrier [%s|%p] is still alive\n",
 279                (*bI).first.c_str(),
 280                (*bI).second));
 281
 282     }
 283
 284     CondVarStore::MPFieldMapCIt cI = _sCondVarStore._mFieldMap.begin();
 285     CondVarStore::MPFieldMapCIt cE = _sCondVarStore._mFieldMap.end  ();
 286
 287     for(; cI != cE; ++cI)
 288     {
 289         FLOG(("ThreadManager::dump: "
 290               "condvar [%s|%p] is still alive\n",
 291               (*cI).first.c_str(),
 292               (*cI).second));
 293
 294     }
 295
 296     LockStore::MPFieldMapCIt lI = _sLockStore._mFieldMap.begin();
 297     LockStore::MPFieldMapCIt lE = _sLockStore._mFieldMap.end  ();
 298
 299     for(; lI != lE; ++lI)
 300     {
 301         FLOG(("ThreadManager::dump: "
 302               "lock [%s|%p] is still alive\n",
 303               (*lI).first.c_str(),
 304               (*lI).second));
 305     }
 306
 307     LockPoolStore::MPFieldMapCIt lpI = _sLockPoolStore._mFieldMap.begin();
 308     LockPoolStore::MPFieldMapCIt lpE = _sLockPoolStore._mFieldMap.end  ();
 309
 310     for(; lpI != lpE; ++lpI)
 311     {
 312         FLOG(("ThreadManager::dump: "
 313               "lockpool [%s|%p] is still alive\n",
 314               (*lpI).first.c_str(),
 315               (*lpI).second));
 316
 317     }
 318
 319     SemaphoreStore::MPFieldMapCIt sI = _sSemaphoreStore._mFieldMap.begin();
 320     SemaphoreStore::MPFieldMapCIt sE = _sSemaphoreStore._mFieldMap.end  ();
 321
 322     for(; sI != sE; ++sI)
 323     {
 324         FLOG(("ThreadManager::dump: "
 325               "semaphore [%s|%p] is still alive\n",
 326               (*sI).first.c_str(),
 327               (*sI).second));
 328     }
 329
 330     FLOG(
 331         ("Sizes: ThreadStore: %"PRISize" BarrierStore: %"PRISize
 332          " CondVarStore: %"PRISize" LockStore: %"PRISize" LockPoolStore: %"
 333          PRISize" SemaphoreStore: %"PRISize"\n",
 334          _sThreadStore   ._mFieldMap.size(),
 335          _sBarrierStore  ._mFieldMap.size(),
 336          _sCondVarStore  ._mFieldMap.size(),
 337          _sLockStore     ._mFieldMap.size(),
 338          _sLockPoolStore ._mFieldMap.size(),
 339          _sSemaphoreStore._mFieldMap.size()));
 340 }
 341
 342 /*------------------------------- Get -------------------------------------*/
 343
 344 #if defined(OSG_USE_SPROC)
 345 usptr_t *ThreadManager::getArena(void)
 346 {
 347     return _pArena;
 348 }
 349 #endif
 350
 351 /*------------------------------ Helper -----------------------------------*/
 352
 353 bool ThreadManager::initialize(void)
 354 {
 355     return the()->init();
 356 }
 357
 358 bool ThreadManager::terminate (void)
 359 {
 360     bool returnValue = the()->shutdown();
 361
 362     delete _pThreadManager;
 363
 364     _pThreadManager = NULL;
 365
 366     return returnValue;
 367 }
 368
 369 void ThreadManager::remove(BaseThread *pThread)
 370 {
 371     if(_bShutdownInProgress == true)
 372         return;
 373
 374     _storePLock->acquire();
 375
 376     _sThreadStore.removeMPField(pThread);
 377
 378     _storePLock->release();
 379 }
 380
 381 void ThreadManager::remove(Barrier *pBarrier)
 382 {
 383     if(_bShutdownInProgress == true)
 384         return;
 385
 386     _storePLock->acquire();
 387
 388     _sBarrierStore.removeMPField(pBarrier);
 389
 390     _storePLock->release();
 391 }
 392
 393 void ThreadManager::remove(CondVar *pCondVar)
 394 {
 395     if(_bShutdownInProgress == true)
 396         return;
 397
 398     _storePLock->acquire();
 399
 400     _sCondVarStore.removeMPField(pCondVar);
 401
 402     _storePLock->release();
 403 }
 404
 405 void ThreadManager::remove(Lock *pLock)
 406 {
 407     if(_bShutdownInProgress == true)
 408         return;
 409
 410     _storePLock->acquire();
 411
 412     _sLockStore.removeMPField(pLock);
 413
 414     _storePLock->release();
 415 }
 416
 417 void ThreadManager::remove(LockPool *pLockPool)
 418 {
 419     if(_bShutdownInProgress == true)
 420         return;
 421
 422     _storePLock->acquire();
 423
 424     _sLockPoolStore.removeMPField(pLockPool);
 425
 426     _storePLock->release();
 427 }
 428
 429 void ThreadManager::remove(Semaphore *pSemaphore)
 430 {
 431     if(_bShutdownInProgress == true)
 432         return;
 433
 434     _storePLock->acquire();
 435
 436     _sSemaphoreStore.removeMPField(pSemaphore);
 437
 438     _storePLock->release();
 439 }
 440
 441 UInt32 ThreadManager::registerThreadType(MPThreadType *pType)
 442 {
 443     return _sThreadStore.registerMPType(pType);
 444 }
 445
 446 UInt32 ThreadManager::registerBarrierType(MPBarrierType *pType)
 447 {
 448     return _sBarrierStore.registerMPType(pType);
 449 }
 450
 451 UInt32 ThreadManager::registerCondVarType(MPCondVarType *pType)
 452 {
 453     return _sCondVarStore.registerMPType(pType);
 454 }
 455
 456 UInt32 ThreadManager::registerLockType(MPLockType *pType)
 457 {
 458     return _sLockStore.registerMPType(pType);
 459 }
 460
 461 UInt32 ThreadManager::registerLockPoolType(MPLockPoolType *pType)
 462 {
 463     return _sLockPoolStore.registerMPType(pType);
 464 }
 465
 466 UInt32 ThreadManager::registerSemaphoreType(MPSemaphoreType *pType)
 467 {
 468     return _sSemaphoreStore.registerMPType(pType);
 469 }
 470
 471 #ifdef __sgi
 472 #pragma set woff 1209
 473 #endif
 474
 475 bool ThreadManager::init(void)
 476 {
 477     bool returnValue = true;
 478
 479     FDEBUG(("OSGThreadManager init\n"))
 480
 481 #if defined(OSG_USE_SPROC)
 482     usconfig(CONF_AUTOGROW,   1);
 483     usconfig(CONF_INITUSERS, 20);
 484     usconfig(CONF_INITSIZE, 10 * 1048576);
 485     usconfig(CONF_CHMOD, 0666);
 486
 487     _pArena = usinit("/dev/zero");
 488
 489     if(_pArena == NULL)
 490     {
 491         SFATAL << "OSGTM : could not initialize arena " << errno << std::endl;
 492         returnValue = false;
 493     }
 494     else
 495     {
 496         SINFO << "OSGTM : got arena " << _pArena << std::endl;
 497     }
 498 #endif
 499
 500     _storePLock = _sLockStore.getMPField("OSGTMStoreLock", "OSGLock", true);
 501
 502     if(_storePLock == NULL)
 503     {
 504         SFATAL << "OSGTM : could not get table lock" << std::endl;
 505
 506         returnValue = false;
 507     }
 508     else
 509     {
 510         SINFO << "OSGTM : got table lock " << _storePLock << std::endl;
 511     }
 512
 513     if(_szAppThreadType == NULL)
 514     {
 515         FINFO(("OSGTM : create -OSGBaseThread- app thread\n"));
 516
 517         _pAppThread = getThread("OSGAppThread", true, "OSGBaseThread");
 518     }
 519     else
 520     {
 521         FINFO(("OSGTM : create -%s- app thread\n", _szAppThreadType));
 522
 523         _pAppThread = getThread("OSGAppThread", true, _szAppThreadType);
 524     }
 525
 526     FFASSERT((_pAppThread != NULL), 1,
 527              ("OSGTM : could not get application thread \n"););
 528
 529
 530     FINFO(("OSGTM : got application thread %p\n", _pAppThread.get()));
 531
 532     _pAppThread->init();
 533
 534     return returnValue;
 535 }
 536
 537 #ifdef __sgi
 538 #pragma reset woff 1209
 539 #endif
 540
 541 bool ThreadManager::shutdown(void)
 542 {
 543     FDEBUG(("OSGThreadManager shutdown\n"))
 544
 545     _bShutdownInProgress = true;
 546
 547     _pAppThread->shutdown();
 548
 549     _pAppThread = NULL;
 550
 551 #ifdef OSG_DEBUG
 552
 553     ThreadStore::MPFieldMapCIt tI = _sThreadStore._mFieldMap.begin();
 554     ThreadStore::MPFieldMapCIt tE = _sThreadStore._mFieldMap.end  ();
 555
 556     for(; tI != tE; ++tI)
 557     {
 558         if(tI->first != "OSGAppThread")
 559         {
 560             FWARNING(("ThreadManager::shutdown: "
 561                       "thread [%s|%p] is still alive ([%d]). \n",
 562                       (*tI).first.c_str(),
 563                       (*tI).second,
 564                       (*tI).second->exists()));
 565         }
 566     }
 567
 568     BarrierStore::MPFieldMapCIt bI = _sBarrierStore._mFieldMap.begin();
 569     BarrierStore::MPFieldMapCIt bE = _sBarrierStore._mFieldMap.end  ();
 570
 571     for(; bI != bE; ++bI)
 572     {
 573         FWARNING(("ThreadManager::shutdown: "
 574                   "barrier [%s|%p] is still alive\n",
 575                   (*bI).first.c_str(),
 576                   (*bI).second));
 577
 578     }
 579
 580     CondVarStore::MPFieldMapCIt cI = _sCondVarStore._mFieldMap.begin();
 581     CondVarStore::MPFieldMapCIt cE = _sCondVarStore._mFieldMap.end  ();
 582
 583     for(; cI != cE; ++cI)
 584     {
 585         FWARNING(("ThreadManager::shutdown: "
 586                   "condvar [%s|%p] is still alive\n",
 587                   (*cI).first.c_str(),
 588                   (*cI).second));
 589
 590     }
 591
 592     LockStore::MPFieldMapCIt lI = _sLockStore._mFieldMap.begin();
 593     LockStore::MPFieldMapCIt lE = _sLockStore._mFieldMap.end  ();
 594
 595     for(; lI != lE; ++lI)
 596     {
 597         if(lI->first != "OSGTMStoreLock"    &&
 598            lI->first != "OSG::Log::_pLogLock"  )
 599         {
 600             FWARNING(("ThreadManager::shutdown: "
 601                       "lock [%s|%p] is still alive\n",
 602                       (*lI).first.c_str(),
 603                       (*lI).second));
 604         }
 605     }
 606
 607     LockPoolStore::MPFieldMapCIt lpI = _sLockPoolStore._mFieldMap.begin();
 608     LockPoolStore::MPFieldMapCIt lpE = _sLockPoolStore._mFieldMap.end  ();
 609
 610     for(; lpI != lpE; ++lpI)
 611     {
 612         FWARNING(("ThreadManager::shutdown: "
 613                   "lockpool [%s|%p] is still alive\n",
 614                   (*lpI).first.c_str(),
 615                   (*lpI).second));
 616
 617     }
 618
 619     SemaphoreStore::MPFieldMapCIt sI = _sSemaphoreStore._mFieldMap.begin();
 620     SemaphoreStore::MPFieldMapCIt sE = _sSemaphoreStore._mFieldMap.end  ();
 621
 622     for(; sI != sE; ++sI)
 623     {
 624         FWARNING(("ThreadManager::shutdown: "
 625                   "semaphore [%s|%p] is still alive\n",
 626                   (*sI).first.c_str(),
 627                   (*sI).second));
 628     }
 629
 630 #endif
 631
 632     FDEBUG(
 633         ("Sizes: ThreadStore: %"PRISize" BarrierStore: %"PRISize
 634          " CondVarStore: %"PRISize" LockStore: %"PRISize" LockPoolStore: %"
 635          PRISize" SemaphoreStore: %"PRISize"\n",
 636          _sThreadStore   ._mFieldMap.size(),
 637          _sBarrierStore  ._mFieldMap.size(),
 638          _sCondVarStore  ._mFieldMap.size(),
 639          _sLockStore     ._mFieldMap.size(),
 640          _sLockPoolStore ._mFieldMap.size(),
 641          _sSemaphoreStore._mFieldMap.size()));
 642
 643     _sThreadStore   .clear();
 644     _sBarrierStore  .clear();
 645     _sCondVarStore  .clear();
 646     _sLockStore     .clear();
 647     _sLockPoolStore .clear();
 648     _sSemaphoreStore.clear();
 649
 650     Thread::terminateThreading();
 651
 652 #if defined(OSG_USE_SPROC)
 653     if(_pArena != NULL)
 654         usdetach(_pArena);
 655 #endif
 656
 657     return true;
 658 }
 659
 660 /*--------------------------- Constructors --------------------------------*/
 661
 662 ThreadManager::ThreadManager(void) :
 663     _sThreadStore   (    ),
 664     _sBarrierStore  (    ),
 665     _sCondVarStore  (    ),
 666     _sLockStore     (    ),
 667     _sLockPoolStore (    ),
 668     _sSemaphoreStore(    ),
 669
 670     _storePLock     (NULL)
 671 {
 672 #if defined(OSG_USE_SPROC)
 673     _pArena = NULL;
 674 #endif
 675 }
 676
 677 /*---------------------------- Destructo ----------------------------------*/
 678
 679 ThreadManager::~ThreadManager(void)
 680 {
 681     delete [] _szAppThreadType;
 682 }
 683