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