*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

dep/ACE_wrappers/ace/Thread_Manager.h

@@ -1,4 +1,5 @@
 // -*- C++ -*-
+
 //=============================================================================
 /**
  *  @file    Thread_Manager.h
@@ -8,15 +9,19 @@
  *  @author Douglas C. Schmidt <[email protected]>
  */
 //=============================================================================
+
 #ifndef ACE_THREAD_MANAGER_H
 #define ACE_THREAD_MANAGER_H
 #include /**/ "ace/pre.h"
+
 #include "ace/Thread.h"
 #include "ace/Thread_Adapter.h"
 #include "ace/Thread_Exit.h"
+
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
+
 #include "ace/Condition_Thread_Mutex.h"
 #include "ace/Unbounded_Queue.h"
 #include "ace/Containers.h"
@@ -25,6 +30,7 @@
 #include "ace/Log_Msg.h"
 #include "ace/Synch_Traits.h"
 #include "ace/Basic_Types.h"
+
 // The following macros control how a Thread Manager manages a pool of
 // Thread_Descriptor.  Currently, the default behavior is not to
 // preallocate any thread descriptor and never (well, almost never)
@@ -39,33 +45,42 @@
 // system with resources constraint, you may want to lower the size of
 // ACE_DEFAULT_THREAD_MANAGER_HWM to avoid unused memory hanging
 // around.
+
 #if !defined (ACE_DEFAULT_THREAD_MANAGER_PREALLOC)
 # define ACE_DEFAULT_THREAD_MANAGER_PREALLOC 0
 #endif /* ACE_DEFAULT_THREAD_MANAGER_PREALLOC */
+
 #if !defined (ACE_DEFAULT_THREAD_MANAGER_LWM)
 # define ACE_DEFAULT_THREAD_MANAGER_LWM 1
 #endif /* ACE_DEFAULT_THREAD_MANAGER_LWM */
+
 #if !defined (ACE_DEFAULT_THREAD_MANAGER_INC)
 # define ACE_DEFAULT_THREAD_MANAGER_INC 1
 #endif /* ACE_DEFAULT_THREAD_MANAGER_INC */
+
 #if !defined (ACE_DEFAULT_THREAD_MANAGER_HWM)
 # define ACE_DEFAULT_THREAD_MANAGER_HWM ACE_DEFAULT_FREE_LIST_HWM
 // this is a big number
 #endif /* ACE_DEFAULT_THREAD_MANAGER_HWM */
+
 // This is the synchronization mechanism used to prevent a thread
 // descriptor gets removed from the Thread_Manager before it gets
 // stash into it.  If you want to disable this feature (and risk of
 // corrupting the freelist,) you define the lock as ACE_Null_Mutex.
 // Usually, if you can be sure that your threads will run for an
 // extended period of time, you can safely disable the lock.
+
 #if !defined (ACE_DEFAULT_THREAD_MANAGER_LOCK)
 # define ACE_DEFAULT_THREAD_MANAGER_LOCK ACE_SYNCH_MUTEX
 #endif /* ACE_DEFAULT_THREAD_MANAGER_LOCK */
+
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
 // Forward declarations.
 class ACE_Task_Base;
 class ACE_Thread_Manager;
 class ACE_Thread_Descriptor;
+
 /**
   * @class ACE_At_Thread_Exit
   *
@@ -78,30 +93,42 @@ class ACE_Export ACE_At_Thread_Exit
 public:
   /// Default constructor
   ACE_At_Thread_Exit (void);
+
   /// The destructor
   virtual ~ACE_At_Thread_Exit (void);
+
   /// At_Thread_Exit has the ownership?
   bool is_owner (void) const;
+
   /// Set the ownership of the At_Thread_Exit.
   bool is_owner (bool owner);
+
   /// This At_Thread_Exit was applied?
   bool was_applied (void) const;
+
   /// Set applied state of At_Thread_Exit.
   bool was_applied (bool applied);
+
 protected:
   /// The next At_Thread_Exit hook in the list.
   ACE_At_Thread_Exit *next_;
+
   /// Do the apply if necessary
   void do_apply (void);
+
   /// The apply method.
   virtual void apply (void) = 0;
+
   /// The Thread_Descriptor where this at is registered.
   ACE_Thread_Descriptor* td_;
+
   /// The at was applied?
   bool was_applied_;
+
   /// The at has the ownership of this?
   bool is_owner_;
 };
+
 class ACE_Export ACE_At_Thread_Exit_Func : public ACE_At_Thread_Exit
 {
 public:
@@ -109,17 +136,23 @@ public:
    ACE_At_Thread_Exit_Func (void *object,
                             ACE_CLEANUP_FUNC func,
                             void *param = 0);
+
   virtual ~ACE_At_Thread_Exit_Func (void);
+
 protected:
    /// The object to be cleanup
    void *object_;
+
    /// The cleanup func
    ACE_CLEANUP_FUNC func_;
+
    /// A param if required
    void *param_;
+
    /// The apply method
    void apply (void);
 };
+
 /**
  * @class ACE_Thread_Descriptor_Base
  *
@@ -131,6 +164,7 @@ protected:
  */
 class ACE_Export ACE_Thread_Descriptor_Base : public ACE_OS_Thread_Descriptor
 {
+
   friend class ACE_Thread_Manager;
   friend class ACE_Double_Linked_List<ACE_Thread_Descriptor_Base>;
   friend class ACE_Double_Linked_List_Iterator_Base<ACE_Thread_Descriptor_Base>;
@@ -141,37 +175,51 @@ class ACE_Export ACE_Thread_Descriptor_Base : public ACE_OS_Thread_Descriptor
 public:
   ACE_Thread_Descriptor_Base (void);
   ~ACE_Thread_Descriptor_Base (void);
+
   // = We need the following operators to make Borland happy.
+
   /// Equality operator.
   bool operator== (const ACE_Thread_Descriptor_Base &rhs) const;
+
   /// Inequality operator.
   bool operator!= (const ACE_Thread_Descriptor_Base &rhs) const;
+
   /// Group ID.
   int grp_id (void) const;
+
   /// Current state of the thread.
   ACE_UINT32 state (void) const;
+
   /// Return the pointer to an ACE_Task_Base or NULL if there's no
   /// ACE_Task_Base associated with this thread.;
   ACE_Task_Base *task (void) const;
+
 protected:
   /// Reset this base thread descriptor.
   void reset (void);
+
   /// Unique thread ID.
   ACE_thread_t thr_id_;
+
   /// Unique handle to thread (used by Win32 and AIX).
   ACE_hthread_t thr_handle_;
+
   /// Group ID.
   int grp_id_;
+
   /// Current state of the thread.
   ACE_UINT32 thr_state_;
+
   /// Pointer to an ACE_Task_Base or NULL if there's no
   /// ACE_Task_Base.
   ACE_Task_Base *task_;
+
   /// We need these pointers to maintain the double-linked list in a
   /// thread managers.
   ACE_Thread_Descriptor_Base *next_;
   ACE_Thread_Descriptor_Base *prev_;
 };
+
 /**
  * @class ACE_Thread_Descriptor
  *
@@ -187,28 +235,35 @@ class ACE_Export ACE_Thread_Descriptor : public ACE_Thread_Descriptor_Base
 public:
   // = Initialization method.
   ACE_Thread_Descriptor (void);
+
   // = Accessor methods.
   /// Unique thread id.
   ACE_thread_t self (void) const;
+
   /// Unique handle to thread (used by Win32 and AIX).
   void self (ACE_hthread_t &);
+
   /// Dump the state of an object.
   void dump (void) const;
+
   /**
    * This cleanup function must be called only for ACE_TSS_cleanup.
    * The ACE_TSS_cleanup delegate Log_Msg instance destruction when
    * Log_Msg cleanup is called before terminate.
    */
   void log_msg_cleanup(ACE_Log_Msg* log_msg);
+
   /**
    * Register an At_Thread_Exit hook and the ownership is acquire by
    * Thread_Descriptor, this is the usual case when the AT is dynamically
    * allocated.
    */
   int at_exit (ACE_At_Thread_Exit* cleanup);
+
   /// Register an At_Thread_Exit hook and the ownership is retained for the
   /// caller. Normally used when the at_exit hook is created in stack.
   int at_exit (ACE_At_Thread_Exit& cleanup);
+
   /**
    * Register an object (or array) for cleanup at thread termination.
    * "cleanup_hook" points to a (global, or static member) function
@@ -223,8 +278,10 @@ public:
   int at_exit (void *object,
                ACE_CLEANUP_FUNC cleanup_hook,
                void *param);
+
   /// Do nothing destructor to keep some compilers happy
   ~ACE_Thread_Descriptor (void);
+
   /**
    * Do nothing but to acquire the thread descriptor's lock and
    * release.  This will first check if the thread is registered or
@@ -237,46 +294,60 @@ public:
   void acquire_release (void);
   void acquire (void);
   void release (void);
+
   /**
    * Set/get the @c next_ pointer.  These are required by the
    * ACE_Free_List.
    */
   void set_next (ACE_Thread_Descriptor *td);
   ACE_Thread_Descriptor *get_next (void) const;
+
 private:
   /// Reset this thread descriptor.
   void reset (ACE_Thread_Manager *tm);
+
   /// Pop an At_Thread_Exit from at thread termination list, apply the at
   /// if apply is true.
   void at_pop (int apply = 1);
+
   /// Push an At_Thread_Exit to at thread termination list and set the
   /// ownership of at.
   void at_push (ACE_At_Thread_Exit* cleanup,
                 bool is_owner = false);
+
   /// Run the AT_Thread_Exit hooks.
   void do_at_exit (void);
+
   /// Terminate realize the cleanup process to thread termination
   void terminate (void);
+
   /// Thread_Descriptor is the ownership of ACE_Log_Msg if log_msg_!=0
   /// This can occur because ACE_TSS_cleanup was executed before terminate.
   ACE_Log_Msg *log_msg_;
+
   /// The AT_Thread_Exit list
   ACE_At_Thread_Exit *at_exit_list_;
+
   /**
    * Stores the cleanup info for a thread.
    * @note This should be generalized to be a stack of ACE_Cleanup_Info's.
    */
   ACE_Cleanup_Info cleanup_info_;
+
   /// Pointer to an ACE_Thread_Manager or NULL if there's no
   /// ACE_Thread_Manager>
   ACE_Thread_Manager* tm_;
+
   /// Registration lock to prevent premature removal of thread descriptor.
   ACE_DEFAULT_THREAD_MANAGER_LOCK *sync_;
+
   /// Keep track of termination status.
   bool terminated_;
 };
+
 // Forward declaration.
 class ACE_Thread_Control;
+
 // This typedef should be (and used to be) inside the
 // ACE_Thread_Manager declaration.  But, it caused compilation
 // problems on g++/VxWorks/i960 with -g.  Note that
@@ -286,6 +357,7 @@ class ACE_Thread_Control;
 #if defined (__GNUG__)
 typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int);
 #endif /* __GNUG__ */
+
 /**
  * @class ACE_Thread_Manager
  *
@@ -309,34 +381,44 @@ class ACE_Export ACE_Thread_Manager
 {
 public:
   friend class ACE_Thread_Control;
+
   // Allow ACE_THread_Exit to register the global TSS instance object.
   friend class ACE_Thread_Exit;
   friend class ACE_Thread_Descriptor;
+
 #if !defined (__GNUG__)
   typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int);
 #endif /* !__GNUG__ */
+
   /// These are the various states a thread managed by the
   /// ACE_Thread_Manager can be in.
   enum
   {
     /// Uninitialized.
     ACE_THR_IDLE = 0x00000000,
+
     /// Created but not yet running.
     ACE_THR_SPAWNED = 0x00000001,
+
     /// Thread is active (naturally, we don't know if it's actually
     /// *running* because we aren't the scheduler...).
     ACE_THR_RUNNING = 0x00000002,
+
     /// Thread is suspended.
     ACE_THR_SUSPENDED = 0x00000004,
+
     /// Thread has been cancelled (which is an indiction that it needs to
     /// terminate...).
     ACE_THR_CANCELLED = 0x00000008,
+
     /// Thread has shutdown, but the slot in the thread manager hasn't
     /// been reclaimed yet.
     ACE_THR_TERMINATED = 0x00000010,
+
     /// Join operation has been invoked on the thread by thread manager.
     ACE_THR_JOINING = 0x10000000
   };
+
   /**
    * @brief Initialization and termination methods.
    *
@@ -353,17 +435,22 @@ public:
                       size_t inc = ACE_DEFAULT_THREAD_MANAGER_INC,
                       size_t hwm = ACE_DEFAULT_THREAD_MANAGER_HWM);
   ~ACE_Thread_Manager (void);
+
 #if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS)
   /// Get pointer to a process-wide ACE_Thread_Manager.
   static ACE_Thread_Manager *instance (void);
+
   /// Set pointer to a process-wide ACE_Thread_Manager and return
   /// existing pointer.
   static ACE_Thread_Manager *instance (ACE_Thread_Manager *);
+
   /// Delete the dynamically allocated Singleton
   static void close_singleton (void);
 #endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */
+
   /// No-op.  Currently unused.
   int open (size_t size = 0);
+
   /**
    * Release all resources.
    * By default, this method will wait until all threads exit.
@@ -372,6 +459,7 @@ public:
    * up internal thread records (the thread descriptor list).
    */
   int close (void);
+
   /**
    * Create a new thread, which executes @a func with argument @a arg.
    *
@@ -433,6 +521,7 @@ public:
              void *stack = 0,
              size_t stack_size = ACE_DEFAULT_THREAD_STACKSIZE,
              const char** thr_name = 0);
+
   /**
    * Spawn a specified number of threads, all of which execute @a func
    * with argument @a arg.
@@ -509,6 +598,7 @@ public:
                void *stack[] = 0,
                size_t stack_size[] = 0,
                const char* thr_name[] = 0);
+
   /**
    * Spawn a specified number of threads, all of which execute @a func
    * with argument @a arg.
@@ -577,6 +667,7 @@ public:
    *
    * @retval   -1 on failure; @c errno contains an error value.
    * @retval   The group id of the threads.
+
    */
   int spawn_n (ACE_thread_t thread_ids[],
                size_t n,
@@ -590,6 +681,7 @@ public:
                ACE_hthread_t thread_handles[] = 0,
                ACE_Task_Base *task = 0,
                const char* thr_name[] = 0);
+
   /**
    * Called to clean up when a thread exits.
    *
@@ -601,6 +693,7 @@ public:
    */
   ACE_THR_FUNC_RETURN exit (ACE_THR_FUNC_RETURN status = 0,
                             bool do_thread_exit = true);
+
   /**
    * Block until there are no more threads running in this thread
    * manager or @c timeout expires.
@@ -635,14 +728,17 @@ public:
   int wait (const ACE_Time_Value *timeout = 0,
             bool abandon_detached_threads = false,
             bool use_absolute_time = true);
+
   /// Join a thread specified by @a tid.  Do not wait on a detached thread.
   int join (ACE_thread_t tid, ACE_THR_FUNC_RETURN *status = 0);
+
   /**
    * Block until there are no more threads running in a group.
    * Returns 0 on success and -1 on failure.  Notice that wait_grp
    * will not wait on detached threads.
    */
   int wait_grp (int grp_id);
+
   /**
    * Return the "real" handle to the calling thread, caching it if
    * necessary in TSS to speed up subsequent lookups. This is
@@ -654,17 +750,20 @@ public:
    * Return -1 if fail.
    */
   int thr_self (ACE_hthread_t &);
+
   /**
    * Return the unique ID of the calling thread.
    * Same as calling ACE_Thread::self().
    */
   ACE_thread_t thr_self (void);
+
   /**
    * Returns a pointer to the current ACE_Task_Base we're executing
    * in if this thread is indeed running in an ACE_Task_Base, else
    * return 0.
    */
   ACE_Task_Base *task (void);
+
   /**
    * @name Suspend and resume methods
    *
@@ -672,29 +771,39 @@ public:
    * does not support these functions.
    */
   //@{
+
   /// Suspend all threads
   int suspend_all (void);
+
   /// Suspend a single thread.
   int suspend (ACE_thread_t);
+
   /// Suspend a group of threads.
   int suspend_grp (int grp_id);
+
   /**
    * True if @a t_id is inactive (i.e., suspended), else false.  Always
    * return false if @a t_id is not managed by the Thread_Manager.
    */
   int testsuspend (ACE_thread_t t_id);
+
   /// Resume all stopped threads
   int resume_all (void);
+
   /// Resume a single thread.
   int resume (ACE_thread_t);
+
   /// Resume a group of threads.
   int resume_grp (int grp_id);
+
   /**
    * True if @a t_id is active (i.e., resumed), else false.  Always
    * return false if @a t_id is not managed by the Thread_Manager.
    */
   int testresume (ACE_thread_t t_id);
+
   //@}
+
   // = Send signals to one or more threads without blocking.
   /**
    * Send @a signum to all stopped threads.  Not supported on platforms
@@ -711,24 +820,29 @@ public:
    * that do not have advanced signal support, such as Win32.
    */
   int kill_grp (int grp_id, int signum);
+
   // = Cancel methods, which provides a cooperative thread-termination mechanism (will not block).
   /**
    * Cancel's all the threads.
    */
   int cancel_all (int async_cancel = 0);
+
   /**
    * Cancel a single thread.
    */
   int cancel (ACE_thread_t, int async_cancel = 0);
+
   /**
    * Cancel a group of threads.
    */
   int cancel_grp (int grp_id, int async_cancel = 0);
+
   /**
    * True if @a t_id is cancelled, else false.  Always return false if
    * @a t_id is not managed by the Thread_Manager.
    */
   int testcancel (ACE_thread_t t_id);
+
   /**
    * True if @a t_id has terminated (i.e., is no longer running),
    * but the slot in the thread manager hasn't been reclaimed yet,
@@ -736,12 +850,15 @@ public:
    * Thread_Manager.
    */
   int testterminate (ACE_thread_t t_id);
+
   /// Set group ids for a particular thread id.
   int set_grp (ACE_thread_t,
                int grp_id);
+
   /// Get group ids for a particular thread id.
   int get_grp (ACE_thread_t,
                int &grp_id);
+
   /**
    * @name Task-related operations
    */
@@ -759,18 +876,22 @@ public:
    * @retval -1 Failure (consult errno for further information).
    */
   int wait_task (ACE_Task_Base *task);
+
   /**
    * Suspend all threads in an ACE_Task.
    */
   int suspend_task (ACE_Task_Base *task);
+
   /**
    * Resume all threads in an ACE_Task.
    */
   int resume_task (ACE_Task_Base *task);
+
   /**
    * Send a signal @a signum to all threads in an ACE_Task.
    */
   int kill_task (ACE_Task_Base *task, int signum);
+
   /**
    * Cancel all threads in an ACE_Task.  If <async_cancel> is non-0,
    * then asynchronously cancel these threads if the OS platform
@@ -778,17 +899,22 @@ public:
    * cancellation.
    */
   int cancel_task (ACE_Task_Base *task, int async_cancel = 0);
+
   //@}
+
   // = Collect thread handles in the thread manager.  Notice that
   //   the collected information is just a snapshot.
   /// Check if the thread is managed by the thread manager.  Return true if
   /// the thread is found, false otherwise.
   int hthread_within (ACE_hthread_t handle);
   int thread_within (ACE_thread_t tid);
+
   /// Returns the number of ACE_Task_Base in a group.
   int num_tasks_in_group (int grp_id);
+
   /// Returns the number of threads in an ACE_Task_Base.
   int num_threads_in_task (ACE_Task_Base *task);
+
   /**
    * Returns a list of ACE_Task_Base pointers corresponding to the tasks
    * that have active threads in a specified thread group.
@@ -815,6 +941,7 @@ public:
   ssize_t task_list (int grp_id,
                      ACE_Task_Base *task_list[],
                      size_t n);
+
   /**
    * Returns in @a thread_list a list of up to @a n thread ids in an
    * ACE_Task_Base.  The caller must allocate the memory for
@@ -825,6 +952,7 @@ public:
   ssize_t thread_list (ACE_Task_Base *task,
                        ACE_thread_t thread_list[],
                        size_t n);
+
   /**
    * Returns in @a hthread_list a list of up to @a n thread handles in
    * an ACE_Task_Base.  The caller must allocate memory for
@@ -835,6 +963,7 @@ public:
   ssize_t hthread_list (ACE_Task_Base *task,
                         ACE_hthread_t hthread_list[],
                         size_t n);
+
   /**
    * Returns in @a thread_list a list of up to @a n thread ids in a
    * group @a grp_id.  The caller must allocate the memory for
@@ -845,6 +974,7 @@ public:
   ssize_t thread_grp_list (int grp_id,
                            ACE_thread_t thread_list[],
                            size_t n);
+
   /**
    * Returns in @a hthread_list a list of up to @a n thread handles in
    * a group @a grp_id.  The caller must allocate memory for
@@ -853,6 +983,7 @@ public:
   ssize_t hthread_grp_list (int grp_id,
                             ACE_hthread_t hthread_list[],
                             size_t n);
+
   /**
    * Returns a list of ACE_Task_Base pointers corresponding to the tasks
    * that have active threads managed by this instance.
@@ -876,6 +1007,7 @@ public:
    */
   ssize_t task_all_list (ACE_Task_Base *task_list[],
                          size_t n);
+
   /**
    * Returns in @a thread_list a list of up to @a n thread ids.  The
    * caller must allocate the memory for @a thread_list.  In case of an
@@ -885,25 +1017,32 @@ public:
    */
   ssize_t thread_all_list (ACE_thread_t thread_list[],
                            size_t n);
+
   /// Set group ids for a particular task.
   int set_grp (ACE_Task_Base *task, int grp_id);
+
   /// Get group ids for a particular task.
   int get_grp (ACE_Task_Base *task, int &grp_id);
+
   /// Return a count of the current number of threads active in the
   /// <Thread_Manager>.
   size_t count_threads (void) const;
+
   /// Get the state of the thread. Returns false if the thread is not
   /// managed by this thread manager.
   int thr_state (ACE_thread_t id, ACE_UINT32& state);
+
   /**
    * Register an At_Thread_Exit hook and the ownership is acquire by
    * Thread_Descriptor, this is the usual case when the AT is dynamically
    * allocated.
    */
   int at_exit (ACE_At_Thread_Exit* cleanup);
+
   /// Register an At_Thread_Exit hook and the ownership is retained for the
   /// caller. Normally used when the at_exit hook is created in stack.
   int at_exit (ACE_At_Thread_Exit& cleanup);
+
   /**
    *
    *****
@@ -927,14 +1066,18 @@ public:
   int at_exit (void *object,
                ACE_CLEANUP_FUNC cleanup_hook,
                void *param);
+
   /// Access function to determine whether the Thread_Manager will
   /// wait for its thread to exit or not when being closing down.
   void wait_on_exit (int dowait);
   int wait_on_exit (void);
+
   /// Dump the state of an object.
   void dump (void);
+
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
+
 protected:
   // = Accessors for ACE_Thread_Descriptors.
   /**
@@ -943,12 +1086,15 @@ protected:
    * fetch the info from TSS.
    */
   ACE_Thread_Descriptor *thread_desc_self (void);
+
   /// Return a pointer to the thread's Thread_Descriptor,
   /// 0 if fail.
   ACE_Thread_Descriptor *thread_descriptor (ACE_thread_t);
+
   /// Return a pointer to the thread's Thread_Descriptor,
   /// 0 if fail.
   ACE_Thread_Descriptor *hthread_descriptor (ACE_hthread_t);
+
   /// Create a new thread (must be called with locks held).
   int spawn_i (ACE_THR_FUNC func,
                void *arg,
@@ -961,14 +1107,18 @@ protected:
                size_t stack_size = 0,
                ACE_Task_Base *task = 0,
                const char** thr_name = 0);
+
   /// Run the registered hooks when the thread exits.
   void run_thread_exit_hooks (int i);
+
   /// Locate the index of the table slot occupied by <t_id>.  Returns
   /// -1 if <t_id> is not in the table doesn't contain <t_id>.
   ACE_Thread_Descriptor *find_thread (ACE_thread_t t_id);
+
   /// Locate the index of the table slot occupied by <h_id>.  Returns
   /// -1 if <h_id> is not in the table doesn't contain <h_id>.
   ACE_Thread_Descriptor *find_hthread (ACE_hthread_t h_id);
+
   /**
    * Locate the thread descriptor address of the list occupied by
    * @a task.  Returns 0 if @a task is not in the table doesn't contain
@@ -976,11 +1126,13 @@ protected:
    */
   ACE_Thread_Descriptor *find_task (ACE_Task_Base *task,
                                     size_t slot = 0);
+
   /// Insert a thread in the table (checks for duplicates).
   int insert_thr (ACE_thread_t t_id,
                   ACE_hthread_t,
                   int grp_id = -1,
                   long flags = 0);
+
   /// Append a thread in the table (adds at the end, growing the table
   /// if necessary).
   int append_thr (ACE_thread_t t_id, ACE_hthread_t,
@@ -989,13 +1141,17 @@ protected:
                   ACE_Task_Base *task = 0,
                   long flags = 0,
                   ACE_Thread_Descriptor *td = 0);
+
   /// Remove thread from the table.
   void remove_thr (ACE_Thread_Descriptor *td,
                    int close_handler);
+
   /// Remove all threads from the table.
   void remove_thr_all (void);
+
   // = The following four methods implement a simple scheme for
   // operating on a collection of threads atomically.
+
   /**
    * Efficiently check whether @a thread is in a particular @a state.
    * This call updates the TSS cache if possible to speed up
@@ -1004,36 +1160,47 @@ protected:
   int check_state (ACE_UINT32 state,
                    ACE_thread_t thread,
                    int enable = 1);
+
   /// Apply @a func to all members of the table that match the @a task
   int apply_task (ACE_Task_Base *task,
                   ACE_THR_MEMBER_FUNC func,
                   int = 0);
+
   /// Apply @a func to all members of the table that match the @a grp_id.
   int apply_grp (int grp_id,
                  ACE_THR_MEMBER_FUNC func,
                  int arg = 0);
+
   /// Apply @a func to all members of the table.
   int apply_all (ACE_THR_MEMBER_FUNC,
                  int  = 0);
+
   /// Join the thread described in @a td.
   int join_thr (ACE_Thread_Descriptor *td,
                 int = 0);
+
   /// Resume the thread described in @a td.
   int resume_thr (ACE_Thread_Descriptor *td,
                   int = 0);
+
   /// Suspend the thread described in @a td.
   int suspend_thr (ACE_Thread_Descriptor *td,
                    int = 0);
+
   /// Send signal @a signum to the thread described in @a td.
   int kill_thr (ACE_Thread_Descriptor *td,
                 int signum);
+
   /// Set the cancellation flag for the thread described in @a td.
   int cancel_thr (ACE_Thread_Descriptor *td,
                   int async_cancel = 0);
+
   /// Register a thread as terminated and put it into the <terminated_thr_list_>.
   int register_as_terminated (ACE_Thread_Descriptor *td);
+
   /// Setting the static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_ pointer.
   static int set_thr_exit (ACE_TSS_TYPE (ACE_Thread_Exit) *ptr);
+
   /**
    * Keeping a list of thread descriptors within the thread manager.
    * Double-linked list enables us to cache the entries in TSS
@@ -1041,44 +1208,58 @@ protected:
    * affecting other thread's descriptor entries.
    */
   ACE_Double_Linked_List<ACE_Thread_Descriptor> thr_list_;
+
 #if !defined (ACE_HAS_VXTHREADS)
   /// Collect terminated but not yet joined thread entries.
   ACE_Double_Linked_List<ACE_Thread_Descriptor_Base> terminated_thr_list_;
 #endif /* !ACE_HAS_VXTHREADS */
+
   /// Collect pointers to thread descriptors of threads to be removed later.
   ACE_Unbounded_Queue<ACE_Thread_Descriptor*> thr_to_be_removed_;
+
   /// Keeps track of the next group id to assign.
   int grp_id_;
+
   /// Set if we want the Thread_Manager to wait on all threads before
   /// being closed, reset otherwise.
   int automatic_wait_;
+
   // = ACE_Thread_Mutex and condition variable for synchronizing termination.
 #if defined (ACE_HAS_THREADS)
   /// Serialize access to the <zero_cond_>.
   ACE_Thread_Mutex lock_;
+
   /// Keep track of when there are no more threads.
   ACE_Condition_Thread_Mutex zero_cond_;
 #endif /* ACE_HAS_THREADS */
+
   ACE_Locked_Free_List<ACE_Thread_Descriptor, ACE_SYNCH_MUTEX> thread_desc_freelist_;
+
 private:
 #if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS)
   /// Pointer to a process-wide ACE_Thread_Manager.
   static ACE_Thread_Manager *thr_mgr_;
+
   /// Must delete the thr_mgr_ if true.
   static bool delete_thr_mgr_;
+
   /// Global ACE_TSS (ACE_Thread_Exit) object ptr.
   static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_;
 #endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */
 };
+
 #if defined (ACE_THREAD_MANAGER_LACKS_STATICS)
 #define ACE_THREAD_MANAGER_SINGLETON_DEFINE \
         ACE_Singleton<ACE_Thread_Manager, ACE_SYNCH_MUTEX>;
 typedef ACE_Singleton<ACE_Thread_Manager, ACE_SYNCH_MUTEX> ACE_THREAD_MANAGER_SINGLETON;
 #endif /* defined (ACE_THREAD_MANAGER_LACKS_STATICS) */
+
 ACE_END_VERSIONED_NAMESPACE_DECL
+
 #if defined (__ACE_INLINE__)
 #include "ace/Thread_Manager.inl"
 #endif /* __ACE_INLINE__ */
+
 #include /**/ "ace/post.h"
 #endif /* ACE_THREAD_MANAGER_H */