(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.27 and 1.36

version 1.27, 2002/09/17 18:01:03 version 1.36, 2003/04/16 00:17:14
Line 183 
Line 183 
  
 ThreadPool::~ThreadPool(void) ThreadPool::~ThreadPool(void)
 { {
      try
      {
    _pools.remove(this);    _pools.remove(this);
    _dying++;    _dying++;
    Thread *th = 0;    Thread *th = 0;
Line 230 
Line 231 
       delete th;       delete th;
       th = _dead.remove_first();       th = _dead.remove_first();
    }    }
      }
      catch(...)
      {
      }
 } }
  
 // make this static to the class // make this static to the class
Line 267 
Line 271 
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       myself->exit_self(0);       myself->exit_self(0);
    }    }
      catch(...)
      {
         PEG_METHOD_EXIT();
         myself->exit_self(0);
      }
   
    if(sleep_sem == 0 || deadlock_timer == 0)    if(sleep_sem == 0 || deadlock_timer == 0)
    {    {
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
Line 428 
Line 438 
    // 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)
    {    {
         Tracer::trace(TRC_THREAD, Tracer::LEVEL4, "ThreadPool:: removing and joining dead thread");
       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 457 
Line 456 
    int i = 0;    int i = 0;
    AtomicInt needed(0);    AtomicInt needed(0);
  
 //   for( ; i < 2; i++) << Fri Sep 13 12:49:46 2002 mdd >>  #ifdef PEGASUS_DISABLE_KILLING_HUNG_THREADS
 // This change prevents the thread pool from 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 too long.     // The definition of a "hung" thread is one that has been on the run queue
 // "too long" is defined as a time interval that is set when the thread pool is created.     // for longer than the time interval set when the thread pool was created.
 // Cancelling "hung" threads has proved to be problematic.     // Cancelling "hung" threads has proven to be problematic.
   
 // With this change the thread pool will not cancel hung threads. This may prevent a     // With this change the thread pool will not cancel "hung" threads.  This
 // crash depending upon the state of the hung thread. It will cause the thread to hang     // may prevent a crash depending upon the state of the "hung" thread.  In
 // around and not do anything besides waste space.     // 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.     // 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++)    for( ; i < 1; i++)
   #else
      for( ; i < 2; i++)
   #endif
    {    {
       q = map[i];       q = map[i];
       if(q->count() > 0 )       if(q->count() > 0 )
Line 542 
Line 545 
  
                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 560 
Line 564 
                      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
                        Tracer::trace(TRC_THREAD, Tracer::LEVEL4, "Killing a deadlocked thread");
                        th->cancel();
                        delete th;
                     }
                  }
             }             }
             th = q->next(th);             th = q->next(th);
             pegasus_sleep(1);             pegasus_sleep(1);
Line 593 
Line 603 
  
    struct timeval now, finish, remaining;    struct timeval now, finish, remaining;
    Uint32 usec;    Uint32 usec;
    gettimeofday(&now, NULL);     pegasus_gettimeofday(&now);
      /* remove valgrind error */
      pegasus_gettimeofday(&remaining);
   
  
    finish.tv_sec = start->tv_sec + interval->tv_sec;    finish.tv_sec = start->tv_sec + interval->tv_sec;
    usec = start->tv_usec + interval->tv_usec;    usec = start->tv_usec + interval->tv_usec;
Line 607 
Line 620 
       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();  
       delete myself;  
       Thread::test_cancel();  
       Thread::exit_self(0);  
    }  
    return((PEGASUS_THREAD_RETURN)0);  
 } }
  
  
Line 660 
Line 663 
    th->put_tsd("sleep sem", &_sleep_sem_del, sizeof(Semaphore), (void *)sleep_sem);    th->put_tsd("sleep sem", &_sleep_sem_del, sizeof(Semaphore), (void *)sleep_sem);
  
    struct timeval *dldt = (struct timeval *) ::operator new(sizeof(struct timeval));    struct timeval *dldt = (struct timeval *) ::operator new(sizeof(struct timeval));
      pegasus_gettimeofday(dldt);
   
    th->put_tsd("deadlock timer", thread_data::default_delete, sizeof(struct timeval), (void *)dldt);    th->put_tsd("deadlock timer", thread_data::default_delete, sizeof(struct timeval), (void *)dldt);
    // thread will enter _loop(void *) and sleep on sleep_sem until we signal it    // thread will enter _loop(void *) and sleep on sleep_sem until we signal it
    th->run();    th->run();

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