(file) Return to Thread.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Thread.cpp between version 1.29.2.1 and 1.32

version 1.29.2.1, 2002/10/28 15:43:24 version 1.32, 2003/03/18 22:35:27
Line 238 
Line 238 
 { {
    PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::_loop");    PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::_loop");
  
   #if defined(PEGASUS_DEBUG)
      char trace_buf[24];
      snprintf(trace_buf, 23, "%d", (Uint32)pegasus_thread_self());
      Tracer::trace(TRC_THREAD, Tracer::LEVEL4, "ThreadPool::_loop entered by %s", trace_buf);
   #endif
   
   
    Thread *myself = (Thread *)parm;    Thread *myself = (Thread *)parm;
    if(myself == 0)    if(myself == 0)
    {    {
Line 264 
Line 271 
    }    }
    catch(IPCException &)    catch(IPCException &)
    {    {
   #if defined(PEGASUS_DEBUG)
         Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                       "%s: IPCException Caught - EXITING", trace_buf);
   #endif
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       myself->exit_self(0);       myself->exit_self(0);
    }    }
      catch(...)
      {
   #if defined(PEGASUS_DEBUG)
         Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                       "%s: Unknown  Exception Caught - EXITING", trace_buf);
   #endif
         PEG_METHOD_EXIT();
         myself->exit_self(0);
      }
   
    if(sleep_sem == 0 || deadlock_timer == 0)    if(sleep_sem == 0 || deadlock_timer == 0)
    {    {
   #if defined(PEGASUS_DEBUG)
         Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                       "%s: NULL Semaphore  - EXITING", trace_buf);
   #endif
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       throw NullPointer();       throw NullPointer();
    }    }
  
    while(pool->_dying < 1)    while(pool->_dying < 1)
    {    {
   #if defined(PEGASUS_DEBUG)
         Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                       "%s: ThreadPool::_loop - waiting on semaphore", trace_buf);
   #endif
       sleep_sem->wait();       sleep_sem->wait();
   #if defined(PEGASUS_DEBUG)
         Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                       "%s: ThreadPool::_loop - awakened from semaphore", trace_buf);
   #endif
       // when we awaken we reside on the running queue, not the pool queue       // when we awaken we reside on the running queue, not the pool queue
       if(pool->_dying > 0)       if(pool->_dying > 0)
          break;          break;
  
   
       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *_work)(void *) = 0;       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *_work)(void *) = 0;
       void *parm = 0;       void *parm = 0;
  
Line 297 
Line 330 
       }       }
       catch(IPCException &)       catch(IPCException &)
       {       {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: IPCException Caught - EXITING", trace_buf);
   #endif
          PEG_METHOD_EXIT();          PEG_METHOD_EXIT();
          myself->exit_self(0);          myself->exit_self(0);
       }       }
  
       if(_work == 0)       if(_work == 0)
       {       {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: NULL work pointer - EXITING", trace_buf);
   #endif
          PEG_METHOD_EXIT();          PEG_METHOD_EXIT();
          throw NullPointer();          throw NullPointer();
       }       }
   
         if(_work ==
            (PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *)(void *)) &_undertaker)
         {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: Calling the Undertaker", trace_buf);
   #endif
            _work(parm);
         }
   
       gettimeofday(deadlock_timer, NULL);       gettimeofday(deadlock_timer, NULL);
       try       try
       {       {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: ThreadPool::_loop - calling work routine", trace_buf);
   #endif
          _work(parm);          _work(parm);
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: ThreadPool::_loop - returned from work routine", trace_buf);
   #endif
       }       }
       catch(...)       catch(...)
       {       {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: Unknown  Exception Caught - EXITING");
   #endif
          gettimeofday(deadlock_timer, NULL);          gettimeofday(deadlock_timer, NULL);
       }       }
       gettimeofday(deadlock_timer, NULL);       gettimeofday(deadlock_timer, NULL);
Line 327 
Line 391 
       }       }
       catch(IPCException &)       catch(IPCException &)
       {       {
   #if defined(PEGASUS_DEBUG)
            Tracer::trace(__FILE__, __LINE__, TRC_THREAD, Tracer::LEVEL4,
                          "%s: IPCException Caught - EXITING", trace_buf);
   #endif
          PEG_METHOD_EXIT();          PEG_METHOD_EXIT();
          myself->exit_self(0);          myself->exit_self(0);
       }       }
   
    }    }
    // wait to be awakend by the thread pool destructor    // wait to be awakend by the thread pool destructor
    sleep_sem->wait();    sleep_sem->wait();
Line 422 
Line 489 
    // first go thread the dead q and clean it up as much as possible    // first go thread the dead q and clean it up as much as possible
    while(_dead.count() > 0)    while(_dead.count() > 0)
    {    {
   
   #if !defined(PEGASUS_PLATFORM_HPUX_ACC) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
         PEGASUS_STD(cout) << "ThreadPool:: removing and joining dead thread" << PEGASUS_STD(endl);
   #endif
       Thread *dead = _dead.remove_first();       Thread *dead = _dead.remove_first();
       if(dead == 0)       if(dead == 0)
          throw NullPointer();          throw NullPointer();
       if(dead->_handle.thid != 0)        dead->join();
       {  
          dead->detach();  
          destroy_thread(dead->_handle.thid, 0);  
          dead->_handle.thid = 0;  
          while(dead->_cleanup.count() )  
          {  
             // this may throw a permission exception,  
             // which I will remove from the code prior to stabilizing  
             dead->cleanup_pop(true);  
          }  
       }  
       delete dead;       delete dead;
       pegasus_sleep(1);  
    }    }
  
    DQueue<Thread> * map[2] =    DQueue<Thread> * map[2] =
Line 451 
Line 510 
    int i = 0;    int i = 0;
    AtomicInt needed(0);    AtomicInt needed(0);
  
   #ifdef PEGASUS_DISABLE_KILLING_HUNG_THREADS
      // This change prevents the thread pool from killing "hung" threads.
      // The definition of a "hung" thread is one that has been on the run queue
      // for longer than the time interval set when the thread pool was created.
      // Cancelling "hung" threads has proven to be problematic.
   
      // With this change the thread pool will not cancel "hung" threads.  This
      // may prevent a crash depending upon the state of the "hung" thread.  In
      // the case that the thread is actually hung, this change causes the
      // thread resources not to be reclaimed.
   
      // Idle threads, those that have not executed a routine for a time
      // interval, continue to be destroyed.  This is normal and should not
      // cause any problems.
      for( ; i < 1; i++)
   #else
    for( ; i < 2; i++)    for( ; i < 2; i++)
   #endif
    {    {
       q = map[i];       q = map[i];
       if(q->count() > 0 )       if(q->count() > 0 )
Line 477 
Line 553 
             }             }
             catch(...)             catch(...)
             {             {
                  q->unlock();
                return bodies;                return bodies;
             }             }
  
Line 522 
Line 599 
  
                if(th != 0)                if(th != 0)
                {                {
                     if( i == 0 )
                     {
                   th->delete_tsd("work func");                   th->delete_tsd("work func");
                   th->put_tsd("work func", NULL,                   th->put_tsd("work func", NULL,
                               sizeof( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *)(void *)),                               sizeof( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *)(void *)),
Line 535 
Line 613 
  
                   if(sleep_sem == 0)                   if(sleep_sem == 0)
                   {                   {
                           q->unlock();
                      th->dereference_tsd();                      th->dereference_tsd();
                      throw NullPointer();                      throw NullPointer();
                   }                   }
  
                   // put the thread on the dead  list  
                   _dead.insert_first(th);  
                   bodies++;                   bodies++;
                   sleep_sem->signal();  
   
                   th->dereference_tsd();                   th->dereference_tsd();
                        _dead.insert_first(th);
                        sleep_sem->signal();
                   th = 0;                   th = 0;
                }                }
                     else
                     {
                        // deadlocked threads
   #if !defined(PEGASUS_PLATFORM_HPUX_ACC) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
                        PEGASUS_STD(cout) << "Killing a deadlocked thread" << PEGASUS_STD(endl);
   #endif
                        th->cancel();
                        delete th;
                     }
                  }
             }             }
             th = q->next(th);             th = q->next(th);
             pegasus_sleep(1);             pegasus_sleep(1);
Line 586 
Line 673 
       return false;       return false;
 } }
  
   
 PEGASUS_THREAD_RETURN ThreadPool::_undertaker( void *parm ) PEGASUS_THREAD_RETURN ThreadPool::_undertaker( void *parm )
 { {
    Thread *myself = reinterpret_cast<Thread *>(parm);     exit_thread((PEGASUS_THREAD_RETURN)1);
    if(myself != 0)     return (PEGASUS_THREAD_RETURN)1;
    {  
       myself->detach();  
       myself->_handle.thid = 0;  
       myself->cancel();  
       myself->test_cancel();  
       myself->exit_self(0);  
    }  
    return((PEGASUS_THREAD_RETURN)0);  
 } }
  
  
Line 630 
Line 708 
  
  Thread *ThreadPool::_init_thread(void) throw(IPCException)  Thread *ThreadPool::_init_thread(void) throw(IPCException)
 { {
      PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::_init_thread");
    Thread *th = (Thread *) new Thread(_loop, this, false);    Thread *th = (Thread *) new Thread(_loop, this, false);
    // allocate a sleep semaphore and pass it in the thread context    // allocate a sleep semaphore and pass it in the thread context
    // initial count is zero, loop function will sleep until    // initial count is zero, loop function will sleep until
Line 643 
Line 722 
    th->run();    th->run();
    _current_threads++;    _current_threads++;
    pegasus_yield();    pegasus_yield();
      PEG_METHOD_EXIT();
  
    return th;    return th;
 } }

Legend:
Removed from v.1.29.2.1  
changed lines
  Added in v.1.32
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2