(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 and 1.30

version 1.29, 2002/09/20 02:06:18 version 1.30, 2003/02/13 14:53:10
Line 267 
Line 267 
       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 434 
    // 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)
    {    {
         PEGASUS_STD(cout) << "ThreadPool:: removing and joining dead thread" << PEGASUS_STD(endl);
       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 452 
    int i = 0;    int i = 0;
    AtomicInt needed(0);    AtomicInt needed(0);
  
 //   for( ; i < 2; i++) << Fri Sep 13 12:49:46 2002 mdd >>  
 // 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.  
 // "too long" is defined as a time interval that is set when the thread pool is created.  
 // Cancelling "hung" threads has proved 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. It will cause the thread to hang  
 // around and not do anything besides waste space.  
   
 // 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 < 2; i++)
    {    {
       q = map[i];       q = map[i];
       if(q->count() > 0 )       if(q->count() > 0 )
Line 540 
Line 523 
  
                th = q->remove_no_lock((void *)th);                th = q->remove_no_lock((void *)th);
  
                // ATTN-DME-P3-20020919 This code assumes that the thread being  
                // killed is 'alive' and available to respond to a terminate  
                // request quickly. Since this code is only processing threads  
                // on the _pool (i.e., idle) queue this assumption is currently  
                // valid. However, this code should not be called if the  
                // thread is truly 'hung' or executing a long running request  
                // because it will cause this thread to wait.  
   
                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 568 
Line 544 
                      throw NullPointer();                      throw NullPointer();
                   }                   }
  
 #ifdef DO_NOT_IMPLEMENT_THREAD_POOL_FIX  
                   // The above code activates an idle thread to run the  
                   // _undertaker method. This will cause the thread to  
                   // terminate.  The issue with placing this  
                   // thread on the _dead queue is that it creates a timing  
                   // problem. If the kill_dead_threads procedure is called  
                   // before this thread has a chance to execute, or while  
                   // this thread is executing, the thread object may be  
                   // deleted prematurely.  This can cause the CIM Server  
                   // or the ThreadPool test to core dump or hang.  
                   //  
                   // 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                    }
                   // Wait until the thread exits before deleting the                    else
                   // thread object and related data structures.                    {
                   //                       // deadlocked threads
                        PEGASUS_STD(cout) << "Killing a deadlocked thread" << PEGASUS_STD(endl);
                   th->cancel();                   th->cancel();
                   th->dereference_tsd();  
                   sleep_sem->signal();  
                   th->join();  
                   th->empty_tsd();  
                   delete th;                   delete th;
                   th=0;                    }
                   bodies++;  
 #endif  
                }                }
             }             }
             th = q->next(th);             th = q->next(th);
Line 639 
Line 597 
       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();  
 #ifdef DO_NOT_IMPLEMENT_THREAD_POOL_FIX  
       // Implementations of the join operation rely on the  
       // value of the handle.thid to implement the join operation.  
       // Setting this value to 0 can cause the thread  
       // issuing the join call to hang.  
       myself->_handle.thid = 0;  
 #endif  
       myself->cancel();  
       myself->test_cancel();  
       myself->exit_self(0);  
    }  
    return((PEGASUS_THREAD_RETURN)0);  
 } }
  
  

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