TAO/tao/Dynamic_TP/DTP_Thread_Pool.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file DTP_Thread_Pool.h
   6  *
   7  *  @author Irfan Pyarali
   8  *  @author Johnny Willemsen
   9  *  @author Phil Mesnier
  10  */
  11 // ===================================================================
  12
  13 #ifndef TAO_DTP_THREAD_POOL_H
  14 #define TAO_DTP_THREAD_POOL_H
  15
  16 #include /**/ "ace/pre.h"
  17 #include "tao/orbconf.h"
  18
  19 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
  20
  21 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  22 # pragma once
  23 #endif /* ACE_LACKS_PRAGMA_ONCE */
  24
  25 #include "ace/Hash_Map_Manager.h"
  26 #include "tao/Thread_Lane_Resources.h"
  27 #include "tao/Dynamic_TP/dynamic_tp_export.h"
  28 #include "tao/Dynamic_TP/DTP_Config.h"
  29 #include "tao/New_Leader_Generator.h"
  30 #include "ace/Task.h"
  31 #include "ace/Null_Mutex.h"
  32
  33 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  34
  35 class TAO_ORB_Core;
  36 class TAO_DTP_Thread_Pool;
  37 class TAO_DTP_Thread_Pool_Manager;
  38
  39 /**
  40  * @class TAO_DTP_New_Leader_Generator
  41  *
  42  * @brief Class for creating dynamic threads.
  43  *
  44  * \nosubgrouping
  45  *
  46  **/
  47 class TAO_Dynamic_TP_Export TAO_DTP_New_Leader_Generator
  48   : public TAO_New_Leader_Generator
  49 {
  50 public:
  51   /// Constructor.
  52   TAO_DTP_New_Leader_Generator (TAO_DTP_Thread_Pool &lane);
  53
  54   /// Leader/Follower class uses this method to notify the system that
  55   /// we are out of leaders.
  56   bool no_leaders_available ();
  57
  58 private:
  59   /// Pool associated with this leader generator.
  60   TAO_DTP_Thread_Pool &pool_;
  61 };
  62
  63 /**
  64  * @class TAO_DTP_Thread_Pool_Threads
  65  *
  66  * @brief Class representing a static thread running in a thread lane.
  67  *
  68  * \nosubgrouping
  69  *
  70  **/
  71 class TAO_DTP_Thread_Pool_Threads : public ACE_Task_Base
  72 {
  73 public:
  74   /// Constructor.
  75   TAO_DTP_Thread_Pool_Threads (TAO_DTP_Thread_Pool &pool);
  76
  77   /// Method executed when a thread is spawned.
  78   int svc ();
  79
  80   /// Accessor to the pool to which this thread belongs to.
  81   TAO_DTP_Thread_Pool &pool () const;
  82
  83 protected:
  84   /// Do the real work
  85   virtual int run (TAO_ORB_Core &orb_core);
  86
  87   /// Pool to which this thread belongs to.
  88   TAO_DTP_Thread_Pool &pool_;
  89 };
  90
  91 /**
  92  * @class TAO_DTP_Termination_Waiter
  93  *
  94  * @brief A thread pool helper that simply waits for the detached
  95  * threads to signal their termination so ORB shutdown can be orderly
  96  *
  97  **/
  98 class TAO_DTP_Termination_Waiter : public ACE_Task_Base
  99 {
 100 public:
 101   /// Constructor.
 102   TAO_DTP_Termination_Waiter (TAO_DTP_Thread_Pool &pool);
 103
 104   /// Method executed when a thread is spawned.
 105   int svc ();
 106
 107 protected:
 108   /// Pool to which this thread belongs to.
 109   TAO_DTP_Thread_Pool &pool_;
 110 };
 111
 112 /**
 113  * @class TAO_DTP_Thread_Pool
 114  *
 115  * @brief Class representing the thread pool inside a thread pool
 116  * manager.
 117  *
 118  * \nosubgrouping
 119  *
 120  **/
 121 class TAO_Dynamic_TP_Export TAO_DTP_Thread_Pool
 122 {
 123 public:
 124   friend class TAO_DTP_Thread_Pool_Threads;
 125   friend class TAO_DTP_Termination_Waiter;
 126
 127   TAO_DTP_Thread_Pool (TAO_DTP_Thread_Pool_Manager &manager,
 128                        CORBA::ULong id,
 129                        TAO_DTP_Definition &definition);
 130
 131   /// Destructor.
 132   ~TAO_DTP_Thread_Pool ();
 133
 134   /// Open the pool.
 135   void open ();
 136
 137   /// Wait for threads to exit.
 138   void wait ();
 139
 140   /// Mark this thread pool that we are shutting down.
 141   void shutting_down ();
 142
 143   /// Create the initial threads - only called once.
 144   int create_initial_threads ();
 145
 146   /// Called by the TAO_DTP_New_Leader_Generator to request a new dynamic
 147   /// thread.
 148   /**
 149    * It can be that no thread can be created because the number of
 150    * threads is equal to the maximum we can have or the Thread Lane
 151    * is shutting down.
 152    * @retval true A new thread is created
 153    * @retval false No thread could be created
 154    */
 155   bool new_dynamic_thread ();
 156
 157   /// Called by the run loop to determine if to expire a thread or not
 158   /// when the dynamic timeout is reached.
 159   bool above_minimum ();
 160
 161   /// @name Accessors
 162   // @{
 163   bool use_timeouts () const;
 164   const ACE_Time_Value& dynamic_thread_time () const;
 165
 166   TAO_DTP_Thread_Pool_Manager &manager () const;
 167   CORBA::ULong id () const;
 168   CORBA::ULong current_threads () const;
 169   void add_active ();
 170   bool remove_active (bool force);
 171
 172   // @}
 173
 174 private:
 175   int create_threads_i (size_t count);
 176
 177   TAO_DTP_Thread_Pool_Manager &manager_;
 178
 179   CORBA::ULong id_;
 180
 181   /// This boolean is set when we are shutting down, then we will not create
 182   /// any new dynamic threads
 183   bool shutdown_;
 184
 185   TAO_DTP_Definition definition_;
 186   TAO_DTP_Thread_Pool_Threads threads_;
 187   TAO_DTP_Termination_Waiter waiter_;
 188
 189   CORBA::ULong active_count_;
 190
 191   TAO_DTP_New_Leader_Generator new_thread_generator_;
 192
 193   /// Lock to guard all members of the pool
 194   mutable TAO_SYNCH_MUTEX lock_;
 195
 196   /// synchronzing new threads with the requester of threads
 197   TAO_SYNCH_MUTEX activation_lock_;
 198   TAO_SYNCH_CONDITION activation_cond_;
 199
 200   /// synchronzing new threads with the requester of threads
 201   TAO_SYNCH_MUTEX termination_lock_;
 202   TAO_SYNCH_CONDITION termination_cond_;
 203 };
 204
 205 /**
 206  * @class TAO_DTP_Thread_Pool_Manager
 207  *
 208  * @brief Class for managing thread pools.
 209  *
 210  * \nosubgrouping
 211  *
 212  **/
 213 class TAO_Dynamic_TP_Export TAO_DTP_Thread_Pool_Manager
 214 {
 215 public:
 216   /// Constructor.
 217   TAO_DTP_Thread_Pool_Manager (TAO_ORB_Core &orb_core);
 218
 219   /// Destructor.
 220   ~TAO_DTP_Thread_Pool_Manager ();
 221
 222   /// Wait for threads to exit.
 223   void wait ();
 224
 225   /// Create a threadpool without lanes.
 226   CORBA::ULong create_threadpool (TAO_DTP_Definition &def);
 227
 228   /// Destroy a threadpool.
 229   void destroy_threadpool (CORBA::ULong threadpool);
 230
 231   /// Collection of thread pools.
 232   typedef ACE_Hash_Map_Manager<CORBA::ULong, TAO_DTP_Thread_Pool *,
 233                                ACE_Null_Mutex> THREAD_POOLS;
 234
 235   /// @name Accessors
 236   // @{
 237   TAO_ORB_Core &orb_core () const;
 238   // @}
 239
 240 private:
 241   /// @name Helpers
 242   // @{
 243   CORBA::ULong
 244   create_threadpool_i (TAO_DTP_Definition &def);
 245
 246   CORBA::ULong
 247   create_threadpool_helper (TAO_DTP_Thread_Pool *thread_pool);
 248   // @}
 249
 250 private:
 251   TAO_ORB_Core &orb_core_;
 252
 253   THREAD_POOLS thread_pools_;
 254   CORBA::ULong thread_pool_id_counter_;
 255   TAO_SYNCH_MUTEX lock_;
 256 };
 257
 258 TAO_END_VERSIONED_NAMESPACE_DECL
 259
 260 #if defined (__ACE_INLINE__)
 261 #include "tao/Dynamic_TP/DTP_Thread_Pool.inl"
 262 #endif /* __ACE_INLINE__ */
 263
 264 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */
 265
 266 #include /**/ "ace/post.h"
 267
 268 #endif /* TAO_THREAD_POOL_H */