This commit was manufactured by cvs2svn to create branchunlabeled-4.1.2

'unlabeled-4.1.2'.

1 files changed, 0 insertions, 1032 deletions

diff --git a/ace/Thread_Manager.cpp b/ace/Thread_Manager.cpp
deleted file mode 100644
index ef1370dfb92..00000000000
--- a/ace/Thread_Manager.cpp
+++ /dev/null
@@ -1,1032 +0,0 @@
-// Thread_Manager.cpp
-// $Id$
-
-#define ACE_BUILD_DLL
-#include "ace/Thread_Manager.h"
-
-#if !defined (__ACE_INLINE__)
-#include "ace/Thread_Manager.i"
-#endif /* __ACE_INLINE__ */
-
-ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Control)
-ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Manager)
-
-void
-ACE_Thread_Manager::dump (void) const
-{
-  ACE_TRACE ("ACE_Thread_Manager::dump");
-}
-
-ACE_Thread_Descriptor::ACE_Thread_Descriptor (void)
-  : thr_id_ (ACE_OS::NULL_thread),
-    grp_id_ (0),
-    thr_state_ (ACE_THR_IDLE)
-{
-  ACE_TRACE ("ACE_Thread_Descriptor::ACE_Thread_Descriptor");
-}
-
-// The following macro simplifies subsequence code.
-#define ACE_FIND(OP,INDEX) \
-  int INDEX = OP; \
-  if (INDEX == -1) return -1
-
-int 
-ACE_Thread_Manager::thread_descriptor (ACE_thread_t thr_id,
-				       ACE_Thread_Descriptor &descriptor)
-{
-  ACE_TRACE ("ACE_Thread_Descriptor::thread_descriptor");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_FIND (this->find_thread (thr_id), index);
-  descriptor = this->thr_table_[index];
-  return 0;
-}
-
-
-int 
-ACE_Thread_Manager::hthread_descriptor (ACE_hthread_t thr_handle, 
-					ACE_Thread_Descriptor &descriptor)
-{
-  ACE_TRACE ("ACE_Thread_Descriptor::hthread_descriptor");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_FIND (this->find_hthread (thr_handle), index);
-  descriptor = this->thr_table_[index];
-  return 0;
-}
-
-// Return the thread descriptor (indexed by ACE_hthread_t).
-
-int 
-ACE_Thread_Manager::thr_self (ACE_hthread_t &self)
-{
-  ACE_TRACE ("ACE_Thread_Descriptor::thr_self");  
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  // Try to get the cached HANDLE out of TSS to avoid lookup.
-  ACE_hthread_t *handle = ACE_LOG_MSG->thr_handle ();
-
-  // Wasn't in the cache, so we'll have to look it up and cache it.
-  if (handle == 0) 
-    { 
-      ACE_thread_t id = ACE_OS::thr_self ();
-      
-      ACE_FIND (this->find_thread (id), index);
-      handle = &this->thr_table_[index].thr_handle_;
-
-      // Update the TSS cache. 
-      ACE_LOG_MSG->thr_handle (handle);
-    } 
-  self = *handle;
-  return 0;
-}
-
-int
-ACE_Thread_Manager::resize (size_t size)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resize");
-  ACE_Thread_Descriptor *temp;
-  
-  ACE_NEW_RETURN (temp, ACE_Thread_Descriptor[size], -1);
-
-  for (size_t i = 0; i < this->max_table_size_; i++)
-    temp[i] = this->thr_table_[i]; // Structure assignment.
-
-  this->max_table_size_ = size;
-
-  delete [] this->thr_table_;
-
-  this->thr_table_ = temp;
-  return 0;
-}
-
-// Create and initialize the table to keep track of the thread pool.
-
-int
-ACE_Thread_Manager::open (size_t size)
-{
-  ACE_TRACE ("ACE_Thread_Manager::open");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  if (this->max_table_size_ < size)
-    this->resize (size);
-  return 0;
-}
-
-// Initialize the synchronization variables.
-
-ACE_Thread_Manager::ACE_Thread_Manager (size_t size)
-  : thr_table_ (0),
-    max_table_size_ (0), 
-    current_count_ (0),
-    grp_id_ (1)
-#if defined (ACE_HAS_THREADS)
-    , zero_cond_ (lock_)
-#endif /* ACE_HAS_THREADS */
-{
-  ACE_TRACE ("ACE_Thread_Manager::ACE_Thread_Manager");
-  if (this->open (size) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Thread_Manager"));
-}
-
-// Close up and release all resources.
-
-int
-ACE_Thread_Manager::close (void)
-{
-  ACE_TRACE ("ACE_Thread_Manager::close");
-  if (this->thr_table_ != 0)
-    {
-      delete [] this->thr_table_;
-      this->thr_table_ = 0;
-      this->max_table_size_ = 0;
-      this->current_count_ = 0;
-    }
-  return 0;
-}
-
-ACE_Thread_Manager::~ACE_Thread_Manager (void)
-{
-  ACE_TRACE ("ACE_Thread_Manager::~ACE_Thread_Manager");
-  this->close ();
-}
-
-// Call the appropriate OS routine to spawn a thread.  Should *not* be
-// called with the lock_ held...
-
-int 
-ACE_Thread_Manager::spawn_i (ACE_THR_FUNC func, 
-			     void *args, 
-			     long flags, 
-			     ACE_thread_t *t_id, 
-			     ACE_hthread_t *t_handle,
-			     u_int priority,
-			     int grp_id,
-			     void *stack, 
-			     size_t stack_size,
-			     ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::spawn_i");
-  ACE_thread_t thr_id;
-  ACE_hthread_t thr_handle;
-
-  if (t_id == 0)
-    t_id = &thr_id;
-
-  if (t_handle == 0)
-    t_handle = &thr_handle;
-  
-  int result = ACE_Thread::spawn (func, args, flags, 
-				  t_id, t_handle, priority,
-				  stack, stack_size);
-  if (result != 0)
-    {
-      errno = result;
-      return -1;
-    }
-  else
-    return this->append_thr (*t_id, *t_handle, 
-			     ACE_THR_SPAWNED, 
-			     grp_id, task);
-}
-
-// Create a new thread running FUNC.  *Must* be called with the lock_
-// held...
-
-int 
-ACE_Thread_Manager::spawn (ACE_THR_FUNC func, 
-			   void *args, 
-			   long flags, 
-			   ACE_thread_t *t_id, 
-			   ACE_hthread_t *t_handle,
-			   u_int priority,
-			   int grp_id,
-			   void *stack, 
-			   size_t stack_size)
-{
-  ACE_TRACE ("ACE_Thread_Manager::spawn");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  if (grp_id == -1)
-    grp_id = this->grp_id_++; // Increment the group id.
-
-  if (this->spawn_i (func, args, flags, t_id, t_handle, 
-		     priority, grp_id, stack, stack_size) == -1)
-    return -1;
-  else
-    return grp_id;
-}
-
-// Create N new threads running FUNC.
-
-int 
-ACE_Thread_Manager::spawn_n (int n, 
-			     ACE_THR_FUNC func, 
-			     void *args, 
-			     long flags,
-			     u_int priority,
-			     int grp_id,
-			     ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::spawn_n");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  if (grp_id == -1)
-    grp_id = this->grp_id_++; // Increment the group id.
-
-  for (int i = 0; i < n; i++)
-    {
-      // @@ What should happen if this fails?! e.g., should we try to
-      // cancel the other threads that we've already spawned or what?
-      if (this->spawn_i (func, args, flags, 0, 0, priority, grp_id, 
-			 0, 0, task) == -1)
-	return -1;
-    }
-
-  return grp_id;
-}
-
-// Create N new threads running FUNC.
-
-int 
-ACE_Thread_Manager::spawn_n (ACE_thread_t thread_ids[],
-			     size_t n, 
-			     ACE_THR_FUNC func, 
-			     void *args,
-			     long flags, 
-			     u_int priority,
-			     int grp_id,
-			     void *stack[],
-			     size_t stack_size[],
-			     ACE_hthread_t thread_handles[])
-{
-  ACE_TRACE ("ACE_Thread_Manager::spawn_n");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  if (grp_id == -1)
-    grp_id = this->grp_id_++; // Increment the group id.
-
-  for (size_t i = 0; i < n; i++)
-    {
-      // @@ What should happen if this fails?! e.g., should we try to
-      // cancel the other threads that we've already spawned or what?
-      if (this->spawn_i (func, 
-			 args, 
-			 flags, 
-			 &thread_ids[i], 
-			 thread_handles == 0 ? 0 : &thread_handles[i], 
-			 priority, 
-			 grp_id, 
-			 stack == 0 ? 0 : stack[i], 
-			 stack_size == 0 ? 0 : stack_size[i]) == -1)
-	return -1;
-    }
-
-  return grp_id;
-}
-
-// Append a thread into the pool (does not check for duplicates).
-// Must be called with locks held.
-
-int
-ACE_Thread_Manager::append_thr (ACE_thread_t t_id, 
-				ACE_hthread_t t_handle,
-				ACE_Thread_State thr_state,
-				int grp_id,
-				ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::append_thr");
-  // Try to resize the array to twice its existing size if we run out
-  // of space...
-  if (this->current_count_ >= this->max_table_size_ 
-      && this->resize (this->max_table_size_ * 2) == -1)
-    return -1;
-  else
-    {
-      ACE_Thread_Descriptor &thr_desc = 
-	this->thr_table_[this->current_count_];
-
-      thr_desc.thr_id_ = t_id;
-      thr_desc.thr_handle_ = t_handle;
-      thr_desc.grp_id_ = grp_id;
-      thr_desc.thr_state_ = thr_state;
-      thr_desc.task_ = task;
-
-      this->current_count_++;
-      return 0;
-    }
-}
-
-// Return the thread descriptor (indexed by ACE_hthread_t).
-
-int 
-ACE_Thread_Manager::find_hthread (ACE_hthread_t h_id)
-{
-  ACE_TRACE ("ACE_Thread_Descriptor::find_hthread");  
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (ACE_OS::thr_cmp (h_id, this->thr_table_[i].thr_handle_))
-      return i;
-
-  return -1;
-}
-
-// Locate the index in the table associated with <t_id>.  Must be
-// called with the lock held.
-
-int 
-ACE_Thread_Manager::find_thread (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::find_thread");
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (ACE_OS::thr_equal (t_id, this->thr_table_[i].thr_id_))
-      return i;
-
-  return -1;    
-}
-
-// Insert a thread into the pool (checks for duplicates and doesn't
-// allow them to be inserted twice).
-
-int
-ACE_Thread_Manager::insert_thr (ACE_thread_t t_id, 
-				ACE_hthread_t t_handle,
-				int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::insert_thr");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  // Check for duplicates and bail out if they're already
-  // registered...
-  if (this->find_thread (t_id) != -1)
-    return -1;
-
-  if (grp_id == -1)
-    grp_id = this->grp_id_++;
-    
-  if (this->append_thr (t_id, t_handle, 
-			ACE_THR_SPAWNED,
-			grp_id) == -1)
-    return -1;
-  else
-    return grp_id;
-}
-
-// Remove a thread from the pool.  Must be called with locks held.
-
-void
-ACE_Thread_Manager::remove_thr (int i)
-{
-  ACE_TRACE ("ACE_Thread_Manager::remove_thr");
-  if (this->current_count_ > 1)
-    // Structure assignment.
-    this->thr_table_[i] = this->thr_table_[this->current_count_ - 1];
-
-  this->current_count_--;
-
-#if defined (ACE_HAS_THREADS)
-  // Tell all waiters when there are no more threads left in the pool.
-  if (this->current_count_ == 0)
-    this->zero_cond_.broadcast ();
-#endif /* ACE_HAS_THREADS */
-}
-
-// Factory out some common behavior to simplify the following methods.
-#define ACE_THR_OP(OP,STATE) \
-  int result = OP (this->thr_table_[i].thr_handle_); \
-  if (result != 0) { \
-    this->remove_thr (i); \
-    errno = result; \
-    return -1; \
-  } \
-  else { \
-    this->thr_table_[i].thr_state_ = STATE; \
-    return 0; \
-  }
-
-int
-ACE_Thread_Manager::suspend_thr (int i)
-{
-  ACE_TRACE ("ACE_Thread_Manager::suspend_thr");
-
-  ACE_THR_OP (ACE_Thread::suspend, ACE_THR_SUSPENDED);
-}
-
-int
-ACE_Thread_Manager::resume_thr (int i)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume_thr");
-
-  ACE_THR_OP (ACE_Thread::resume, ACE_THR_RUNNING);
-}
-
-int
-ACE_Thread_Manager::cancel_thr (int i)
-{
-  ACE_TRACE ("ACE_Thread_Manager::cancel_thr");
-  this->thr_table_[i].thr_state_ = ACE_THR_CANCELLED;
-  return 0;
-}
-
-int
-ACE_Thread_Manager::kill_thr (int i, int signum)
-{
-  ACE_TRACE ("ACE_Thread_Manager::kill_thr");
-
-  int result = ACE_Thread::kill ((ACE_thread_t) this->thr_table_[i].thr_id_,
-				 signum);
-
-  if (result != 0)
-    { 
-      // We need to save this across calls to remove_thr() since that
-      // call may reset errno.
-      int error = errno;
-
-      this->remove_thr (i); 
-      errno = error; 
-      return -1; 
-    } 
-  else 
-    return 0; 
-}
-
-#define ACE_EXECUTE_OP(OP) \
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); \
-  ACE_FIND (this->find_thread (t_id), index); \
-  return OP (index);
-
-// Suspend a single thread.
-
-int 
-ACE_Thread_Manager::suspend (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::suspend");
-  ACE_EXECUTE_OP (this->suspend_thr);
-}
-
-// Resume a single thread.
-
-int 
-ACE_Thread_Manager::resume (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume");
-  ACE_EXECUTE_OP (this->resume_thr);
-}
-
-// Cancel a single thread.
-
-int 
-ACE_Thread_Manager::cancel (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::cancel");
-  ACE_EXECUTE_OP (this->cancel_thr);
-}
-
-// Send a signal to a single thread.
-
-int 
-ACE_Thread_Manager::kill (ACE_thread_t t_id, int signum)
-{
-  ACE_TRACE ("ACE_Thread_Manager::kill");
-  return ACE_Thread::kill (t_id, signum);
-}
-
-int
-ACE_Thread_Manager::check_state (ACE_Thread_State state, 
-				 ACE_thread_t id) 
-{
-  ACE_TRACE ("ACE_Thread_Manager::check_state");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_Thread_State *thr_state = 0;
-#if 0
-  int self_check = ACE_OS::thr_equal (id, ACE_OS::thr_self ());
-
-  // If we're checking the state of our thread, try to get the cached
-  // value out of TSS to avoid lookup.
-  if (self_check) 
-    thr_state = ACE_LOG_MSG->thr_state ();
-
-  // Wasn't in the cache, so we'll have to look it up.
-  if (thr_state == 0) 
-    { 
-      ACE_FIND (this->find_thread (id), index);
-      thr_state = &this->thr_table_[index].thr_state_;
-
-      if (self_check) // Update the TSS cache. 
-	ACE_LOG_MSG->thr_state (thr_state); 
-    } 
-#else
-   // Turn off caching for the time being until we figure out 
-   // how to do it correctly in the face of deletions...
-  ACE_FIND (this->find_thread (id), index);
-  thr_state = &this->thr_table_[index].thr_state_;
-#endif /* 0 */
-  return *thr_state == state;
-}
-
-// Test if a single thread is suspended.
-
-int 
-ACE_Thread_Manager::testsuspend (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::testsuspend");
-  return this->check_state (ACE_THR_SUSPENDED, t_id);
-}
-
-// Test if a single thread is active (i.e., resumed).
-
-int 
-ACE_Thread_Manager::testresume (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::testresume");
-  return this->check_state (ACE_THR_RUNNING, t_id);
-}
-
-// Test if a single thread is cancelled.
-
-int 
-ACE_Thread_Manager::testcancel (ACE_thread_t t_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::testcancel");
-  return this->check_state (ACE_THR_CANCELLED, t_id);
-}
-
-// Get group ids for a particular thread id.
-
-int 
-ACE_Thread_Manager::get_grp (ACE_thread_t t_id, int &grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::get_grp");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_FIND (this->find_thread (t_id), index);
-  grp_id = this->thr_table_[index].grp_id_;
-  return 0;
-}
-
-// Set group ids for a particular thread id.
-
-int 
-ACE_Thread_Manager::set_grp (ACE_thread_t t_id, int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::set_grp");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_FIND (this->find_thread (t_id), index);
-  this->thr_table_[index].grp_id_ = grp_id;
-  return 0;
-}
-
-// Suspend a group of threads.
-
-int
-ACE_Thread_Manager::apply_grp (int grp_id, 
-			       THR_FUNC func,
-			       int arg)
-{
-  ACE_TRACE ("ACE_Thread_Manager::apply_grp");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  int result = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].grp_id_ == grp_id
-	&& (this->*func)(i, arg) == -1)
-      result = -1;
-
-  return result;
-}
-
-int 
-ACE_Thread_Manager::suspend_grp (int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::suspend_grp");
-  return this->apply_grp (grp_id, 
-			  THR_FUNC (&ACE_Thread_Manager::suspend_thr));
-}
-
-// Resume a group of threads.
-
-int 
-ACE_Thread_Manager::resume_grp (int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume_grp");
-  return this->apply_grp (grp_id, 
-			  THR_FUNC (&ACE_Thread_Manager::resume_thr));
-}
-
-// Kill a group of threads.
-
-int 
-ACE_Thread_Manager::kill_grp (int grp_id, int signum)
-{
-  ACE_TRACE ("ACE_Thread_Manager::kill_grp");
-  return this->apply_grp (grp_id, 
-			  THR_FUNC (&ACE_Thread_Manager::kill_thr), signum);
-}
-
-// Cancel a group of threads.
-
-int 
-ACE_Thread_Manager::cancel_grp (int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume_grp");
-  return this->apply_grp (grp_id, 
-			  THR_FUNC (&ACE_Thread_Manager::cancel_thr));
-}
-
-int
-ACE_Thread_Manager::apply_all (THR_FUNC func, int arg)
-{
-  ACE_TRACE ("ACE_Thread_Manager::apply_all");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  int result = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if ((this->*func)(i, arg) == -1)
-      result = -1;
-
-  return result;
-}
-
-// Resume all threads that are suspended.
-
-int 
-ACE_Thread_Manager::resume_all (void)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume_all");
-  return this->apply_all (THR_FUNC (&ACE_Thread_Manager::resume_thr));
-}
-
-int 
-ACE_Thread_Manager::suspend_all (void)
-{
-  ACE_TRACE ("ACE_Thread_Manager::suspend_all");
-  return this->apply_all (THR_FUNC (&ACE_Thread_Manager::suspend_thr));
-}
-
-int 
-ACE_Thread_Manager::kill_all (int sig)
-{
-  ACE_TRACE ("ACE_Thread_Manager::kill_all");
-  return this->apply_all (&ACE_Thread_Manager::kill_thr, sig);
-}
-
-int 
-ACE_Thread_Manager::cancel_all (void)
-{
-  ACE_TRACE ("ACE_Thread_Manager::cancel_all");
-  return this->apply_all (THR_FUNC (&ACE_Thread_Manager::cancel_thr));
-}
-
-// Must be called when thread goes out of scope to clean up its table
-// slot.
-
-void *
-ACE_Thread_Manager::exit (void *status, int do_thr_exit)
-{
-  ACE_TRACE ("ACE_Thread_Manager::exit");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
-
-  int i = this->find_thread (ACE_Thread::self ());
-
-  // Locate thread id.
-  if (i != -1)
-    this->remove_thr (i);
-
-  if (do_thr_exit)
-    {
-      // Note, destructor is never called, so we must manually release
-      // the lock...
-
-      ACE_MT (ace_mon.release ()); 
-
-      ACE_Thread::exit (status);
-      // On reasonable systems ACE_Thread::exit() should not return.
-      // However, due to horrible semantics with Win32 thread-specific
-      // storage this call can return (don't ask...).  Therefore, we
-      // need to reacquire the mutex so that we don't get burned when
-      // the Guard automatically releases it when this method returns.
-      ACE_MT (ace_mon.acquire ()); 
-    }
-  return 0;
-}
-
-// Wait for all the threads to exit.
-
-int
-ACE_Thread_Manager::wait (const ACE_Time_Value *timeout)
-{
-  ACE_TRACE ("ACE_Thread_Manager::wait");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-#if defined (ACE_HAS_THREADS)
-  while (this->current_count_ > 0)
-    if (this->zero_cond_.wait (timeout) == -1)
-      return -1;
-#else
-  timeout = timeout;
-#endif /* ACE_HAS_THREADS */
-
-  return 0;
-}
-
-// Wait for task  
-int 
-ACE_Thread_Manager::wait_task (ACE_Task_Base *task,
-			       const ACE_Time_Value *timeout)
-{
-  // This method will be implemented in the future.  The way we
-  // thought about it is by adding a linked list of pointers to
-  // ACE_Condition_Thread_Mutex, where one will be allocated
-  // dynaminclly when needed. Broadcasting the waiters will be done
-  // in a similar manner to what's done today. When a thread is
-  // removed (in remove_thr()) we'll check whether it is last in its
-  // task and whether "somebody" is waiting for this task to end, if
-  // so we'll broadcast the waiters.
-
-  task = task;
-  timeout = timeout;
-  ACE_NOTSUP_RETURN (-1);
-}
-
-// Wait for group of threads
-int 
-ACE_Thread_Manager::wait_group (int grp_id, 
-				const ACE_Time_Value *timeout)
-{
-  // This method will be implemented in the future. See the above
-  // comment.
-  grp_id = grp_id;
-  timeout = timeout;
-  ACE_NOTSUP_RETURN (-1);
-}
-
-int
-ACE_Thread_Manager::apply_task (ACE_Task_Base *task, 
-				THR_FUNC func,
-				int arg)
-{
-  ACE_TRACE ("ACE_Thread_Manager::apply_task");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  int result = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].task_ == task
-	&& (this->*func)(i, arg) == -1)
-      result = -1;
-
-  return result;
-}
-
-// Suspend a task
-int  
-ACE_Thread_Manager::suspend_task (ACE_Task_Base *task)
-{ 
-  ACE_TRACE ("ACE_Thread_Manager::suspend_task");
-  return this->apply_task (task, 
-			   THR_FUNC (&ACE_Thread_Manager::suspend_thr));
-}
-
-// Resume a task.
-int  
-ACE_Thread_Manager::resume_task (ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::resume_task");
-  return this->apply_task (task, 
-			   THR_FUNC (&ACE_Thread_Manager::resume_thr));
-}
-
-// Kill a task.
-int  
-ACE_Thread_Manager::kill_task (ACE_Task_Base *task, int /* signum */)
-{
-  ACE_TRACE ("ACE_Thread_Manager::kill_task");
-  return this->apply_task (task, 
-			   THR_FUNC (&ACE_Thread_Manager::kill_thr));
-}
-
-// Cancel a task.
-int  
-ACE_Thread_Manager::cancel_task (ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::cancel_task");
-  return this->apply_task (task, 
-			   THR_FUNC (&ACE_Thread_Manager::cancel_thr));
-}
-
-// Locate the index in the table associated with <task> from the
-// beginning of the table up to an index.  Must be called with the
-// lock held.
-
-int 
-ACE_Thread_Manager::find_task (ACE_Task_Base *task, 
-			       int index)
-{
-  ACE_TRACE ("ACE_Thread_Manager::find_task");
-
-  if (index == -1)
-      index = current_count_;
-
-  for (int i = 0; i < index; i++)
-    if (task == this->thr_table_[i].task_)
-      return i;
-
-  return -1;    
-}
-
-// Returns the number of ACE_Task in a group. 
-
-int 
-ACE_Thread_Manager::num_tasks_in_group (int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::num_tasks_in_group");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  int tasks_count = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].grp_id_ == grp_id
-	&& this->find_task (thr_table_[i].task_, i) == -1)
-      tasks_count++;
-
-  return tasks_count;
-}
-
-// Returns the number of threads in an ACE_Task.
-
-int 
-ACE_Thread_Manager::num_threads_in_task (ACE_Task_Base *task)
-{
-  ACE_TRACE ("ACE_Thread_Manager::num_threads_in_task");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  int threads_count = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].task_ == task)
-      threads_count++;
-
-  return threads_count;
-}
-
-// Returns in task_list a list of ACE_Tasks in a group.
-
-int 
-ACE_Thread_Manager::task_list (int grp_id, 
-			       ACE_Task_Base *task_list[],
-			       size_t n)
-{
-  ACE_TRACE ("ACE_Thread_Manager::task_list");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_Task_Base **task_list_iterator = task_list;
-  size_t task_list_count = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++) 
-    if (task_list_count < n
-	&& this->thr_table_[i].grp_id_ == grp_id
-	&& this->find_task (thr_table_[i].task_, i) == -1)
-      {
-	task_list_iterator[task_list_count] = this->thr_table_[i].task_;
-	task_list_count++;
-      }
-
-  return 0;
-}
-
-// Returns in thread_list a list of thread ids in an ACE_Task.
-
-int 
-ACE_Thread_Manager::thread_list (ACE_Task_Base *task, 
-				 ACE_thread_t thread_list[],
-				 size_t n)
-{
-  ACE_TRACE ("ACE_Thread_Manager::thread_list");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_thread_t *thread_list_iterator = thread_list;
-  size_t thread_list_count = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (thread_list_count < n && this->thr_table_[i].task_ == task)
-      {
-	thread_list_iterator[thread_list_count] = this->thr_table_[i].thr_id_;
-	thread_list_count++;
-      }
-
-  return 0;
-}
-
-// Returns in thread_list a list of thread handles in an ACE_Task.
-
-int 
-ACE_Thread_Manager::hthread_list (ACE_Task_Base *task, 
-				  ACE_hthread_t hthread_list[],
-				  size_t n)
-{
-  ACE_TRACE ("ACE_Thread_Manager::thread_list");
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_hthread_t *hthread_list_iterator = hthread_list;
-  size_t hthread_list_count = 0;
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].task_ == task 
-	&& hthread_list_count < n)
-      {
-	hthread_list_iterator[hthread_list_count] = 
-	  this->thr_table_[i].thr_handle_;
-	hthread_list_count++;
-      }
-
-  return 0;
-}
-
-int 
-ACE_Thread_Manager::set_grp (ACE_Task_Base *task, int grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::set_grp");
-
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  for (size_t i = 0; i < this->current_count_; i++)
-    if (this->thr_table_[i].task_ == task)
-      this->thr_table_[i].grp_id_ = grp_id;
-  return 0;
-}
-
-int 
-ACE_Thread_Manager::get_grp (ACE_Task_Base *task, int &grp_id)
-{
-  ACE_TRACE ("ACE_Thread_Manager::get_grp");
-
-  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1));
-
-  ACE_FIND (this->find_task (task), index);
-  grp_id = this->thr_table_[index].grp_id_;
-  return 0;
-}
-
-void
-ACE_Thread_Control::dump (void) const
-{
-  ACE_TRACE ("ACE_Thread_Control::dump");
-}
-
-int
-ACE_Thread_Control::insert (ACE_Thread_Manager *tm)
-{
-  ACE_TRACE ("ACE_Thread_Control::insert");
- 
-  ACE_hthread_t t_id;
-  ACE_Thread::self (t_id);
-  this->tm_ = tm;
- 
-  return this->tm_->insert_thr (ACE_Thread::self (), t_id);
-}
-
-// Initialize the thread controller.
-
-ACE_Thread_Control::ACE_Thread_Control (ACE_Thread_Manager *t, 
-					int insert)
-  : tm_ (t),
-    status_ (0)
-{
-  ACE_TRACE ("ACE_Thread_Control::ACE_Thread_Control");
-  if (this->tm_ != 0 && insert)
-    {
-      ACE_hthread_t t_id;
-      ACE_Thread::self (t_id);
-      this->tm_->insert_thr (ACE_Thread::self (), t_id);
-    }
-}
-
-// Automatically kill thread on exit.
-
-ACE_Thread_Control::~ACE_Thread_Control (void)
-{
-  ACE_TRACE ("ACE_Thread_Control::~ACE_Thread_Control");
-#if !defined (ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS)
-  this->exit (this->status_);
-#endif /* ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS */
-}
-
-// Exit from thread (but clean up first).
-
-void *
-ACE_Thread_Control::exit (void *exit_status)
-{
-  ACE_TRACE ("ACE_Thread_Control::exit");
-  if (this->tm_ != 0)
-    return this->tm_->exit (exit_status);
-  else
-    {
-      ACE_Thread::exit (exit_status);
-      return 0;
-    }
-}