ACE/ace/Thread_Manager.inl

   1 // -*- C++ -*-
   2 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 ACE_INLINE
   5 ACE_At_Thread_Exit::ACE_At_Thread_Exit ()
   6   : next_ (0),
   7     td_ (0),
   8     was_applied_ (false),
   9     is_owner_ (true)
  10 {
  11 }
  12
  13 ACE_INLINE bool
  14 ACE_At_Thread_Exit::was_applied() const
  15 {
  16    return was_applied_;
  17 }
  18
  19 ACE_INLINE bool
  20 ACE_At_Thread_Exit::was_applied (bool applied)
  21 {
  22   was_applied_ = applied;
  23   if (was_applied_)
  24     td_ = 0;
  25   return was_applied_;
  26 }
  27
  28 ACE_INLINE bool
  29 ACE_At_Thread_Exit::is_owner() const
  30 {
  31   return is_owner_;
  32 }
  33
  34 ACE_INLINE bool
  35 ACE_At_Thread_Exit::is_owner (bool owner)
  36 {
  37   is_owner_ = owner;
  38   return is_owner_;
  39 }
  40
  41 ACE_INLINE void
  42 ACE_At_Thread_Exit::do_apply ()
  43 {
  44   if (!this->was_applied_ && this->is_owner_)
  45     td_->at_pop();
  46 }
  47
  48 ACE_INLINE
  49 ACE_At_Thread_Exit_Func::ACE_At_Thread_Exit_Func (void *object,
  50                                                   ACE_CLEANUP_FUNC func,
  51                                                   void *param)
  52   : object_(object),
  53     func_(func),
  54     param_(param)
  55 {
  56 }
  57
  58 ACE_INLINE
  59 ACE_Thread_Descriptor_Base::ACE_Thread_Descriptor_Base ()
  60   : ACE_OS_Thread_Descriptor (),
  61     thr_id_ (ACE_OS::NULL_thread),
  62     thr_handle_ (ACE_OS::NULL_hthread),
  63     grp_id_ (0),
  64     thr_state_ (ACE_Thread_Manager::ACE_THR_IDLE),
  65     task_ (0),
  66     next_ (0),
  67     prev_ (0)
  68 {
  69 }
  70
  71 ACE_INLINE
  72 ACE_Thread_Descriptor_Base::~ACE_Thread_Descriptor_Base ()
  73 {
  74 }
  75
  76 ACE_INLINE bool
  77 ACE_Thread_Descriptor_Base::operator== (
  78   const ACE_Thread_Descriptor_Base &rhs) const
  79 {
  80   return
  81     ACE_OS::thr_cmp (this->thr_handle_, rhs.thr_handle_)
  82     && ACE_OS::thr_equal (this->thr_id_, rhs.thr_id_);
  83 }
  84
  85 ACE_INLINE bool
  86 ACE_Thread_Descriptor_Base::operator!=(const ACE_Thread_Descriptor_Base &rhs) const
  87 {
  88   return !(*this == rhs);
  89 }
  90
  91 ACE_INLINE ACE_Task_Base *
  92 ACE_Thread_Descriptor_Base::task () const
  93 {
  94   ACE_TRACE ("ACE_Thread_Descriptor_Base::task");
  95   return this->task_;
  96 }
  97
  98 // Group ID.
  99
 100 ACE_INLINE int
 101 ACE_Thread_Descriptor_Base::grp_id () const
 102 {
 103   ACE_TRACE ("ACE_Thread_Descriptor_Base::grp_id");
 104   return grp_id_;
 105 }
 106
 107 // Current state of the thread.
 108 ACE_INLINE ACE_UINT32
 109 ACE_Thread_Descriptor_Base::state () const
 110 {
 111   ACE_TRACE ("ACE_Thread_Descriptor_Base::state");
 112   return thr_state_;
 113 }
 114
 115 // Reset this base descriptor.
 116 ACE_INLINE void
 117 ACE_Thread_Descriptor_Base::reset ()
 118 {
 119   ACE_TRACE ("ACE_Thread_Descriptor_Base::reset");
 120   this->thr_id_ = ACE_OS::NULL_thread;
 121   this->thr_handle_ = ACE_OS::NULL_hthread;
 122   this->grp_id_ = 0;
 123   this->thr_state_ = ACE_Thread_Manager::ACE_THR_IDLE;
 124   this->task_ = 0;
 125   this->flags_ = 0;
 126 }
 127
 128 // Unique thread id.
 129 ACE_INLINE ACE_thread_t
 130 ACE_Thread_Descriptor::self () const
 131 {
 132   ACE_TRACE ("ACE_Thread_Descriptor::self");
 133   return this->thr_id_;
 134 }
 135
 136 // Unique kernel-level thread handle.
 137
 138 ACE_INLINE void
 139 ACE_Thread_Descriptor::self (ACE_hthread_t &handle)
 140 {
 141   ACE_TRACE ("ACE_Thread_Descriptor::self");
 142   handle = this->thr_handle_;
 143 }
 144
 145 ACE_INLINE void
 146 ACE_Thread_Descriptor::log_msg_cleanup (ACE_Log_Msg* log_msg)
 147
 148 {
 149   log_msg_ = log_msg;
 150 }
 151
 152 // Set the <next_> pointer
 153 ACE_INLINE void
 154 ACE_Thread_Descriptor::set_next (ACE_Thread_Descriptor *td)
 155 {
 156   ACE_TRACE ("ACE_Thread_Descriptor::set_next");
 157   this->next_ = td;
 158 }
 159
 160 // Get the <next_> pointer
 161 ACE_INLINE ACE_Thread_Descriptor *
 162 ACE_Thread_Descriptor::get_next () const
 163 {
 164   ACE_TRACE ("ACE_Thread_Descriptor::get_next");
 165   return static_cast<ACE_Thread_Descriptor *> (this->next_);
 166 }
 167
 168 // Reset this thread descriptor
 169 ACE_INLINE void
 170 ACE_Thread_Descriptor::reset (ACE_Thread_Manager *tm)
 171 {
 172   ACE_TRACE ("ACE_Thread_Descriptor::reset");
 173   this->ACE_Thread_Descriptor_Base::reset ();
 174   this->at_exit_list_ = 0;
 175     // Start the at_exit hook list.
 176   this->tm_ = tm;
 177     // Setup the Thread_Manager.
 178   this->log_msg_ = 0;
 179   this->terminated_ = false;
 180 }
 181
 182 ACE_INLINE ACE_Thread_Descriptor *
 183 ACE_Thread_Manager::thread_desc_self ()
 184 {
 185   // This method must be called with lock held.
 186
 187   // Try to get it from cache.
 188   ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc ();
 189
 190 #if 1
 191   //  ACE_ASSERT (desc != 0);
 192   // Thread descriptor should always get cached.
 193 #else
 194   if (desc == 0)
 195     {
 196       ACE_thread_t id = ACE_OS::thr_self ();
 197
 198       desc = this->find_thread (id);
 199
 200       // Thread descriptor adapter might not have been put into the
 201       // list yet.
 202       if (desc != 0)
 203         // Update the TSS cache.
 204         ACE_LOG_MSG->thr_desc (desc);
 205     }
 206 #endif
 207   return desc;
 208 }
 209
 210 // Return the unique ID of the thread.
 211
 212 ACE_INLINE ACE_thread_t
 213 ACE_Thread_Manager::thr_self ()
 214 {
 215   ACE_TRACE ("ACE_Thread_Manager::thr_self");
 216   return ACE_Thread::self ();
 217 }
 218
 219 ACE_INLINE ACE_Task_Base *
 220 ACE_Thread_Manager::task ()
 221 {
 222   ACE_TRACE ("ACE_Thread_Manager::task");
 223
 224   ACE_Thread_Descriptor *td = this->thread_desc_self () ;
 225
 226   if (td == 0)
 227     return 0;
 228   else
 229     return td->task ();
 230 }
 231
 232 ACE_INLINE int
 233 ACE_Thread_Manager::open (size_t)
 234 {
 235   // Currently no-op.
 236   return 0;
 237 }
 238
 239 ACE_INLINE int
 240 ACE_Thread_Manager::at_exit (ACE_At_Thread_Exit* at)
 241 {
 242   ACE_Thread_Descriptor *td = this->thread_desc_self ();
 243   if (td == 0)
 244     return -1;
 245   else
 246     return td->at_exit (at);
 247 }
 248
 249 ACE_INLINE int
 250 ACE_Thread_Manager::at_exit (ACE_At_Thread_Exit& at)
 251 {
 252   ACE_Thread_Descriptor *td = this->thread_desc_self ();
 253   if (td == 0)
 254     return -1;
 255   else
 256     return td->at_exit (at);
 257 }
 258
 259 ACE_INLINE int
 260 ACE_Thread_Manager::at_exit (void *object,
 261                              ACE_CLEANUP_FUNC cleanup_hook,
 262                              void *param)
 263 {
 264   ACE_Thread_Descriptor *td = this->thread_desc_self ();
 265   if (td == 0)
 266     return -1;
 267   else
 268     return td->at_exit (object, cleanup_hook, param);
 269 }
 270
 271 ACE_INLINE void
 272 ACE_Thread_Manager::wait_on_exit (int do_wait)
 273 {
 274   this->automatic_wait_ = do_wait;
 275 }
 276
 277 ACE_INLINE int
 278 ACE_Thread_Manager::wait_on_exit ()
 279 {
 280   return this->automatic_wait_;
 281 }
 282
 283 ACE_INLINE int
 284 ACE_Thread_Manager::register_as_terminated (ACE_Thread_Descriptor *td)
 285 {
 286 #if defined (ACE_HAS_VXTHREADS)
 287   ACE_UNUSED_ARG (td);
 288 #else  /* ! ACE_HAS_VXTHREADS */
 289   ACE_Thread_Descriptor_Base *tdb = 0;
 290   ACE_NEW_RETURN (tdb, ACE_Thread_Descriptor_Base (*td), -1);
 291   this->terminated_thr_list_.insert_tail (tdb);
 292 #endif /* !ACE_HAS_VXTHREADS */
 293   return 0;
 294 }
 295
 296 ACE_INLINE size_t
 297 ACE_Thread_Manager::count_threads () const
 298 {
 299   return this->thr_list_.size ();
 300 }
 301
 302 ACE_END_VERSIONED_NAMESPACE_DECL