Source/Base/Threading/OSGBaseThread.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include "OSGConfig.h"
  43
  44 #include <iostream>
  45
  46 #include "OSGBaseThread.h"
  47 #include "OSGBaseFunctions.h"
  48 #include "OSGThreadManager.h"
  49 #include "OSGLog.h"
  50
  51 #if ! defined (OSG_USE_PTHREADS) && ! defined (OSG_USE_WINTHREADS)
  52 #define _SGI_MP_SOURCE
  53 #include <sys/types.h>
  54 #include <sys/prctl.h>
  55 #include <cerrno>
  56
  57 #include <sys/types.h>
  58 #include <sys/wait.h>
  59 #include <unistd.h>
  60 #include <signal.h>
  61 #endif
  62
  63 #if defined (OSG_USE_PTHREADS)
  64 #include <signal.h>
  65 #endif
  66
  67 OSG_USING_NAMESPACE
  68
  69 //---------------------------------------------------------------------------
  70 //  Class
  71 //---------------------------------------------------------------------------
  72
  73
  74
  75 /*--------------------------- Constructors --------------------------------*/
  76
  77 BaseThreadCommonBase::BaseThreadCommonBase(const Char8  *szName,
  78                                                  UInt32  uiId,
  79                                                  bool    bGlobal) :
  80
  81      Inherited   (szName, bGlobal),
  82     _uiThreadId  (uiId           ),
  83     _bInitialized(false          )
  84 {
  85 }
  86
  87 /*---------------------------- Destructor ---------------------------------*/
  88
  89 BaseThreadCommonBase::~BaseThreadCommonBase(void)
  90 {
  91 }
  92
  93
  94
  95 #if defined (OSG_USE_PTHREADS)
  96
  97 //---------------------------------------------------------------------------
  98 //  Class
  99 //---------------------------------------------------------------------------
 100
 101 #if defined(OSG_PTHREAD_ELF_TLS)
 102 __thread BaseThread *BasePThreadBase::_pLocalThread = NULL;
 103 #else
 104 pthread_key_t BasePThreadBase::_threadKey;
 105 #endif
 106
 107
 108 BaseThread *BasePThreadBase::getCurrent(void)
 109 {
 110 #ifdef OSG_PTHREAD_ELF_TLS
 111 # ifdef OSG_ENABLE_AUTOINIT_THREADS
 112     if(_pLocalThread == NULL)
 113     {
 114         BaseThreadRefPtr pThread = dynamic_pointer_cast<BaseThread>(
 115             ThreadManager::the()->getThread(NULL, true, "OSGThread"));
 116
 117         pThread->doAutoInit();
 118     }
 119 # endif
 120     return _pLocalThread;
 121 #else
 122     BaseThread **pThread;
 123
 124     pThread = static_cast<BaseThread **>(pthread_getspecific(_threadKey));
 125
 126 # ifdef OSG_ENABLE_AUTOINIT_THREADS
 127     if(pThread == NULL)
 128     {
 129         BaseThreadRefPtr pT = dynamic_pointer_cast<BaseThread>(
 130             ThreadManager::the()->getThread(NULL, true, "OSGThread"));
 131
 132         pT->doAutoInit();
 133
 134         pThread = static_cast<BaseThread **>(pthread_getspecific(_threadKey));
 135     }
 136 #endif
 137
 138     return *pThread;
 139 #endif
 140 }
 141
 142 /*-------------------------------------------------------------------------*/
 143 /*                               Helper                                    */
 144
 145 void *BasePThreadBase::threadFunc(void *pThreadArg)
 146 {
 147     void **pArgs = static_cast<void **>(pThreadArg);
 148
 149     if(pArgs != NULL)
 150     {
 151         if(pArgs[2] != NULL)
 152         {
 153             static_cast<BaseThread *>(pArgs[2])->init();
 154
 155             if(pArgs[0] != NULL)
 156             {
 157                 ThreadFuncF fThreadFunc = ThreadFuncF(pArgs[0]);
 158
 159                 fThreadFunc(pArgs[1]);
 160             }
 161
 162             static_cast<BaseThread *>(pArgs[2])->shutdown();
 163         }
 164     }
 165
 166     return NULL;
 167 }
 168
 169 #if !defined(OSG_PTHREAD_ELF_TLS)
 170 void BasePThreadBase::freeThread(void *pThread)
 171 {
 172     BaseThread **pT = static_cast<BaseThread **>(pThread);
 173
 174     if(pT != NULL)
 175     {
 176         if(*pT != NULL)
 177             OSG::subRef(*pT);
 178
 179         delete pT;
 180     }
 181
 182     pthread_setspecific(_threadKey, NULL);
 183 }
 184 #endif
 185
 186 /*--------------------------- Constructors --------------------------------*/
 187
 188 BasePThreadBase::BasePThreadBase(const Char8  *szName,
 189                                        UInt32  uiId,
 190                                        bool    bGlobal) :
 191     Inherited  (szName, uiId, bGlobal),
 192
 193     _pThreadDesc(NULL),
 194     _pBlockCond (NULL),
 195     _pBlockMutex(NULL)
 196 {
 197     _pThreadData[0] = NULL;
 198     _pThreadData[1] = NULL;
 199     _pThreadData[2] = NULL;
 200 }
 201
 202 /*-------------------------------------------------------------------------*/
 203 /*                             Destructor                                  */
 204
 205 BasePThreadBase::~BasePThreadBase(void)
 206 {
 207     delete _pThreadDesc;
 208
 209     _pThreadDesc = NULL;
 210 }
 211
 212 /*-------------------------------------------------------------------------*/
 213 /*                            Construction                                 */
 214
 215 void BasePThreadBase::setupThread(void)
 216 {
 217 #ifdef OSG_PTHREAD_ELF_TLS
 218     _pLocalThread = static_cast<BaseThread *>(this);
 219 #else
 220     BaseThread **pThread = new BaseThread *;
 221
 222     *pThread = static_cast<BaseThread *>(this);
 223
 224     pthread_setspecific(_threadKey, static_cast<void *>(pThread));
 225 #endif
 226 }
 227
 228 void BasePThreadBase::setupBlockCond(void)
 229 {
 230     _pBlockCond  = new pthread_cond_t;
 231     _pBlockMutex = new pthread_mutex_t;
 232
 233     pthread_cond_init (_pBlockCond, NULL);
 234     pthread_mutex_init(_pBlockMutex, NULL);
 235 }
 236
 237 void BasePThreadBase::doAutoInit(void)
 238 {
 239 }
 240
 241 void BasePThreadBase::init(void)
 242 {
 243     if(_bInitialized == true)
 244         return;
 245
 246     setupThread    ();
 247     setupBlockCond ();
 248
 249     _bInitialized = true;
 250 }
 251
 252 void BasePThreadBase::shutdown(void)
 253 {
 254     if(_bInitialized == false)
 255         return;
 256
 257     pthread_cond_destroy (_pBlockCond);
 258     pthread_mutex_destroy(_pBlockMutex);
 259
 260     delete _pBlockCond;
 261     delete _pBlockMutex;
 262
 263 #if !defined(OSG_PTHREAD_ELF_TLS)
 264     BaseThread **pThread;
 265
 266     pThread = static_cast<BaseThread **>(pthread_getspecific(_threadKey));
 267
 268     delete pThread;
 269
 270     pthread_setspecific(_threadKey, NULL);
 271 #else
 272     _pLocalThread = NULL;
 273 #endif
 274
 275     // TODO release key value, block cond
 276
 277     _bInitialized = false;
 278 }
 279
 280 /*------------------------------ Join -------------------------------------*/
 281
 282 void BasePThreadBase::join(BasePThreadBase *pThread)
 283 {
 284     if(pThread != NULL && pThread->_pThreadDesc != NULL)
 285     {
 286         pthread_join(*(pThread->_pThreadDesc), NULL);
 287
 288         delete pThread->_pThreadDesc;
 289
 290         pThread->_pThreadDesc = NULL;
 291     }
 292 }
 293
 294 /*------------------------------- Run -------------------------------------*/
 295
 296 // This workaround was brought to you by gcc 2.95.3
 297
 298 bool BasePThreadBase::runFunction(ThreadFuncF  fThreadFunc,
 299                                   void        *pThreadArg)
 300 {
 301     bool  returnValue = true;
 302     Int32 rc          = 0;
 303
 304     _bInitialized     = false;
 305
 306     if(fThreadFunc != NULL)
 307     {
 308        if(_pThreadDesc == NULL)
 309             _pThreadDesc = new pthread_t;
 310
 311         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &rc);
 312
 313 #if __GNUC__ < 4
 314         _pThreadData[0] = (void *)(fThreadFunc);
 315 #else
 316         _pThreadData[0] = reinterpret_cast<void *>(fThreadFunc);
 317 #endif
 318         _pThreadData[1] =                          pThreadArg;
 319         _pThreadData[2] = static_cast     <void *>(this       );
 320
 321         rc = pthread_create(_pThreadDesc,
 322                             NULL,
 323                             BasePThreadBase::threadFunc,
 324                             static_cast<void *>(&_pThreadData));
 325
 326         if(rc != 0)
 327         {
 328             SFATAL << "OSGPTB : pthread_create failed" << std::endl;
 329             returnValue = false;
 330         }
 331     }
 332     else
 333     {
 334         SFATAL << "OSGPTB : no thread function given";
 335         returnValue = false;
 336     }
 337
 338     return returnValue;
 339 }
 340
 341 /*------------------------------ Dump -------------------------------------*/
 342
 343 void BasePThreadBase::print(void)
 344 {
 345     fprintf(stderr, "OSGPThreadBase -%s-%d-\n", _szName, _uiThreadId);
 346 }
 347
 348 #endif /* OSG_USE_PTHREADS */
 349
 350
 351
 352
 353 #if defined (OSG_USE_SPROC)
 354
 355 //---------------------------------------------------------------------------
 356 //  Class
 357 //---------------------------------------------------------------------------
 358
 359 /*------------------------------ Helper -----------------------------------*/
 360
 361 void BaseSprocBase::threadFunc(void *pThreadArg)
 362 {
 363     void **pArgs = (void **) pThreadArg;
 364
 365     if(pArgs != NULL)
 366     {
 367         if(pArgs[2] != NULL)
 368         {
 369             ((BaseThread *) pArgs[2])->init();
 370
 371             ((BaseThread *) pArgs[2])->setPid();
 372
 373             if(pArgs[0] != NULL)
 374             {
 375                 ThreadFuncF threadFuncF = (ThreadFuncF) pArgs[0];
 376
 377                 threadFuncF(pArgs[1]);
 378             }
 379         }
 380     }
 381 }
 382
 383 /*--------------------------- Constructors --------------------------------*/
 384
 385 BaseSprocBase::BaseSprocBase(const Char8  *szName,
 386                                    UInt32  uiId  ) :
 387     Inherited(szName, uiId),
 388
 389     _pid     (NULL)
 390 {
 391     _pThreadData[0] = NULL;
 392     _pThreadData[1] = NULL;
 393     _pThreadData[2] = NULL;
 394 }
 395
 396 /*---------------------------- Destructor ---------------------------------*/
 397
 398 BaseSprocBase::~BaseSprocBase(void)
 399 {
 400 }
 401
 402 /*--------------------------- Construction --------------------------------*/
 403
 404 void BaseSprocBase::init(void)
 405 {
 406     if(_bInitialized == true)
 407         return;
 408
 409     setCurrentInternal((BaseThread *) this);
 410
 411     _bInitialized = true;
 412 }
 413
 414 void BaseSprocBase::shutdown(void)
 415 {
 416     _bInitialized = false;
 417 }
 418
 419 void BaseSprocBase::setPid(void)
 420 {
 421     _pid = getpid();
 422 }
 423
 424 void BaseSprocBase::setCurrentInternal(BaseThread *pThread)
 425 {
 426     ((ProcessData *) PRDA->usr_prda.fill)->_pThread  = pThread;
 427 }
 428
 429
 430 /*------------------------------ Join -------------------------------------*/
 431
 432 void BaseSprocBase::join(BaseSprocBase *pThread)
 433 {
 434     if(pThread != NULL)
 435         waitpid(pThread->_pid, NULL, 0);
 436 }
 437
 438 /*------------------------------- Run -------------------------------------*/
 439
 440 // This workaround was brought to you by gcc 2.95.3
 441
 442 bool BaseSprocBase::runFunction(ThreadFuncF  fThreadFunc,
 443                                 void        *pThreadArg)
 444 {
 445     bool  returnValue = true;
 446     Int32 rc          = 0;
 447
 448     _bInitialized     = false;
 449
 450     if(fThreadFunc != NULL)
 451     {
 452         _pThreadData[0] = (void *) fThreadFunc;
 453         _pThreadData[1] =          pThreadArg;
 454         _pThreadData[2] = (void *) this;
 455
 456         rc = sproc(BaseSprocBase::threadFunc, PR_SALL, (void *) _pThreadData);
 457
 458         if(rc == -1)
 459         {
 460             SFATAL << "OSGSPB : sproc thread failed. Reason: "
 461                    << strerror(errno) << std::endl;
 462             returnValue = false;
 463         }
 464     }
 465     else
 466     {
 467         SFATAL << "OSGSPB : no thread function given";
 468         returnValue = false;
 469     }
 470
 471     return returnValue;
 472 }
 473
 474 /*------------------------------- Dump ------------------------------------*/
 475
 476 void BaseSprocBase::print(void)
 477 {
 478     fprintf(stderr, "OSGSprocBase -%s-%d-\n", _szName, _uiThreadId);
 479 }
 480
 481 #endif /* OSG_USE_SPROC */
 482
 483
 484
 485
 486 #if defined (OSG_USE_WINTHREADS)
 487
 488 //---------------------------------------------------------------------------
 489 //  Class
 490 //---------------------------------------------------------------------------
 491
 492 #if defined(OSG_WIN32_ASPECT_USE_LOCALSTORAGE)
 493 UInt32 BaseWinThreadBase::_threadKey = 0;
 494 #else
 495 __declspec (thread) BaseThread *BaseWinThreadBase::_pThreadLocal     = NULL;
 496 #endif
 497
 498 /*------------------------------ Helper -----------------------------------*/
 499
 500 void BaseWinThreadBase::threadFunc(void *pThreadArg)
 501 {
 502     void **pArgs = (void **) pThreadArg;
 503
 504     if(pArgs != NULL)
 505     {
 506         if(pArgs[2] != NULL)
 507         {
 508             ((BaseThread *) pArgs[2])->init();
 509
 510             ((BaseWinThreadBase *) pArgs[2])->setPid();
 511
 512             if(pArgs[0] != NULL)
 513             {
 514                 ThreadFuncF threadFuncF = (ThreadFuncF) pArgs[0];
 515
 516                 threadFuncF(pArgs[1]);
 517             }
 518
 519             static_cast<BaseThread *>(pArgs[2])->shutdown();
 520         }
 521     }
 522 }
 523
 524 /*--------------------------- Constructors --------------------------------*/
 525
 526 BaseWinThreadBase::BaseWinThreadBase(const Char8  *szName,
 527                                            UInt32  uiId,
 528                                            bool    bGlobal) :
 529      Inherited       (szName, uiId, bGlobal),
 530
 531     _pThreadHandle   (NULL),
 532     _pExternalHandle (NULL),
 533     _uiNativeThreadId(0   )
 534 {
 535     _pThreadData[0] = NULL;
 536     _pThreadData[1] = NULL;
 537     _pThreadData[2] = NULL;
 538 }
 539
 540 /*---------------------------- Destructor ---------------------------------*/
 541
 542 BaseWinThreadBase::~BaseWinThreadBase(void)
 543 {
 544 }
 545
 546 BaseThread *BaseWinThreadBase::getCurrent(void)
 547 {
 548 #ifdef OSG_WIN32_ASPECT_USE_LOCALSTORAGE
 549     BaseThread **pThread;
 550
 551     pThread = static_cast<BaseThread **>(TlsGetValue(_threadKey));
 552
 553 # ifdef OSG_ENABLE_AUTOINIT_THREADS
 554     if(pThread == NULL)
 555     {
 556         BaseWinThreadBase *pT = dynamic_cast<BaseThread *>(
 557             ThreadManager::the()->getThread(NULL, "OSGThread"));
 558
 559         pT->doAutoInit();
 560
 561         pThread = (BaseThread **) TlsGetValue(_threadKey);
 562     }
 563 #endif
 564
 565     return *pThread;
 566 #else
 567 # ifdef OSG_ENABLE_AUTOINIT_THREADS
 568     if(_pThreadLocal == NULL)
 569     {
 570         BaseWinThreadBase *pThread = dynamic_cast<BaseThread *>(
 571             ThreadManager::the()->getThread(NULL, "OSGThread"));
 572
 573         pThread->doAutoInit();
 574     }
 575 # endif
 576
 577     return _pThreadLocal;
 578 #endif
 579 }
 580
 581
 582 BaseThread *BaseWinThreadBase::getCurrentInternal(void)
 583 {
 584 #ifdef OSG_WIN32_ASPECT_USE_LOCALSTORAGE
 585     BaseThread **pThread;
 586
 587     pThread = static_cast<BaseThread **>(TlsGetValue(_threadKey));
 588
 589     return (pThread != NULL) ? *pThread : NULL;
 590 #else
 591     return _pThreadLocal;
 592 #endif
 593 }
 594
 595 /*--------------------------- Construction --------------------------------*/
 596
 597 void BaseWinThreadBase::init(void)
 598 {
 599     if(_bInitialized == true)
 600         return;
 601
 602     setupThread();
 603
 604     _bInitialized = true;
 605 }
 606
 607 void BaseWinThreadBase::shutdown(void)
 608 {
 609     if(_bInitialized == false)
 610         return;
 611
 612     // TODO delet key value
 613
 614 #ifdef OSG_WIN32_ASPECT_USE_LOCALSTORAGE
 615     BaseThread **pThread = static_cast<BaseThread **>(TlsGetValue(_threadKey));
 616
 617     delete pThread;
 618
 619     TlsSetValue(_threadKey, NULL);
 620 #else
 621     _pThreadLocal = NULL;
 622 #endif
 623
 624     _bInitialized = false;
 625 }
 626
 627 void BaseWinThreadBase::setPid(void)
 628 {
 629     _pThreadHandle    = GetCurrentThread  ();
 630     _uiNativeThreadId = GetCurrentThreadId();
 631 }
 632
 633 void BaseWinThreadBase::setExternalHandle(Handle pExternalHandle)
 634 {
 635     _pExternalHandle = pExternalHandle;
 636 }
 637
 638
 639 void BaseWinThreadBase::setupThread(void)
 640 {
 641 #if defined (OSG_WIN32_ASPECT_USE_LOCALSTORAGE)
 642     BaseThread **pThread = new BaseThread *;
 643
 644     *pThread = (BaseThread *) this;
 645
 646     TlsSetValue(_threadKey, pThread);
 647 #else
 648     _pThreadLocal = (BaseThread *) this;
 649 #endif
 650 }
 651
 652 void BaseWinThreadBase::doAutoInit(void)
 653 {
 654 }
 655
 656 /*------------------------------ Join -------------------------------------*/
 657
 658 void BaseWinThreadBase::join(BaseWinThreadBase *pThread)
 659 {
 660     if(pThread != NULL)
 661         WaitForSingleObject(pThread->_pExternalHandle, INFINITE);
 662 }
 663
 664 /*------------------------------- Run -------------------------------------*/
 665
 666 // This workaround was brought to you by gcc 2.95.3
 667
 668 bool BaseWinThreadBase::runFunction(ThreadFuncF  fThreadFunc,
 669                                     void        *pThreadArg)
 670 {
 671     bool   returnValue = true;
 672     Handle rc          = 0;
 673     DWord  tmp;
 674
 675     _bInitialized      = false;
 676
 677     if(fThreadFunc != NULL)
 678     {
 679         _pThreadData[0] = (void *) fThreadFunc;
 680         _pThreadData[1] =          pThreadArg;
 681         _pThreadData[2] = (void *) this;
 682
 683         rc = CreateThread(NULL,
 684                           0,
 685                           (LPTHREAD_START_ROUTINE) BaseThreadBase::threadFunc,
 686                           _pThreadData,
 687                           0,
 688                           &tmp);
 689
 690         this->setExternalHandle(rc);
 691
 692         if(rc == NULL)
 693         {
 694             SFATAL << "OSGWTB : sproc thread failed. Reason: "
 695                    << strerror(errno) << std::endl;
 696             returnValue = false;
 697         }
 698     }
 699     else
 700     {
 701         SFATAL << "OSGWTB : no thread function given";
 702         returnValue = false;
 703     }
 704
 705     return returnValue;
 706 }
 707
 708 /*------------------------------- Dump ------------------------------------*/
 709
 710 void BaseWinThreadBase::print(void)
 711 {
 712     fprintf(stderr, "OSGWinThreadBase -%s-%u-\n", _szName, _uiThreadId);
 713 }
 714
 715 #endif /* OSG_USE_WINTHREADS */
 716
 717
 718
 719
 720 //---------------------------------------------------------------------------
 721 //  Class
 722 //---------------------------------------------------------------------------
 723
 724 MPThreadType BaseThread::_type("OSGBaseThread",
 725                                "OSGMPBase",
 726                                &BaseThread::create,
 727                                BaseThread::initThreading);
 728
 729
 730 /*------------------------------- Dump ------------------------------------*/
 731
 732 void BaseThread::print(void)
 733 {
 734     Inherited::print();
 735 }
 736
 737 /*------------------------------- Get -------------------------------------*/
 738
 739 BaseThread::ObjTransitPtr BaseThread::get(const Char8 *szName, bool   bGlobal)
 740 {
 741     return ThreadManager::the()->getThread(szName, bGlobal, "OSGBaseThread");
 742 }
 743
 744 BaseThread *BaseThread::find(const Char8 *szName)
 745 {
 746     return ThreadManager::the()->findThread(szName);
 747 }
 748
 749 /*------------------------------ Helper -----------------------------------*/
 750
 751 BaseThread *BaseThread::create(const Char8 *szName, UInt32 uiId, bool bGlobal)
 752 {
 753     return new BaseThread(szName, uiId, bGlobal);
 754 }
 755
 756 void BaseThread::initThreading(void)
 757 {
 758     FINFO(("BaseThread::initThreading\n"))
 759
 760 #if defined(OSG_USE_PTHREADS) && !defined(OSG_PTHREAD_ELF_TLS)
 761     int rc;
 762
 763     rc = pthread_key_create(&(BaseThread::_threadKey),
 764                               BaseThread::freeThread);
 765
 766     FFASSERT((rc == 0), 1, ("Failed to create pthread thread key\n");)
 767 #endif
 768
 769 #if defined(OSG_USE_WINTHREADS) && defined(OSG_WIN32_ASPECT_USE_LOCALSTORAGE)
 770     BaseThread::_threadKey     = TlsAlloc();
 771
 772     FFASSERT((BaseThread::_threadKey != 0xFFFFFFFF), 1,
 773              ("Failed to alloc thread key local storage\n");)
 774 #endif
 775 }
 776
 777 void BaseThread::terminateThreading(void)
 778 {
 779     FINFO(("BaseThread::terminateThreading\n"));
 780
 781 #if defined(OSG_USE_PTHREADS) && !defined(OSG_PTHREAD_ELF_TLS)
 782     int rc;
 783
 784     rc = pthread_key_delete(BaseThread::_threadKey);
 785
 786     FFASSERT((rc == 0), 1, ("Failed to destroy pthread thread key\n"););
 787 #endif
 788
 789 #if defined(OSG_USE_WINTHREADS) && defined (OSG_WIN32_ASPECT_USE_LOCALSTORAGE)
 790     if(BaseThread::_threadKey != 0xFFFFFFFF)
 791     {
 792         TlsFree(BaseThread::_threadKey);
 793
 794         BaseThread::_threadKey = 0xFFFFFFFF;
 795     }
 796 #endif
 797 }
 798
 799 void BaseThread::runWorkProc(void  *pThread)
 800 {
 801     if(pThread != NULL)
 802     {
 803         static_cast<BaseThread *>(pThread)->workProc();
 804     }
 805 }
 806
 807 /*--------------------------- Constructors --------------------------------*/
 808
 809 BaseThread::BaseThread(const Char8 *szName, UInt32 uiId, bool bGlobal) :
 810     Inherited(szName, uiId, bGlobal)
 811 {
 812 }
 813
 814 /*---------------------------- Destructor ---------------------------------*/
 815
 816 BaseThread::~BaseThread(void)
 817 {
 818     shutdown();
 819
 820     _bGlobal = false;
 821
 822     ThreadManager::the()->remove(this);
 823
 824     if(this != ThreadManager::getAppThread())
 825         terminate();
 826 }
 827
 828 /*------------------------------- Workproc --------------------------------*/
 829
 830 void BaseThread::workProc(void)
 831 {
 832 }