TAO/tao/Leader_Follower.inl

   1 // -*- C++ -*-
   2 // ****************************************************************
   3
   4 #include "tao/ORB_Core_TSS_Resources.h"
   5 #include "tao/ORB_Core.h"
   6
   7 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 ACE_INLINE
  10 TAO_Leader_Follower::TAO_Leader_Follower (TAO_ORB_Core* orb_core,
  11                                           TAO_New_Leader_Generator *new_leader_generator)
  12   : orb_core_ (orb_core),
  13     reverse_lock_ (lock_),
  14     leaders_ (0),
  15     clients_ (0),
  16     reactor_ (0),
  17     avoid_client_leader_ (false),
  18     client_thread_is_leader_ (0),
  19     event_loop_threads_waiting_ (0),
  20     event_loop_threads_condition_ (lock_),
  21     new_leader_generator_ (new_leader_generator)
  22 {
  23 }
  24
  25 ACE_INLINE TAO_ORB_Core_TSS_Resources *
  26 TAO_Leader_Follower::get_tss_resources () const
  27 {
  28   return this->orb_core_->get_tss_resources ();
  29 }
  30
  31 ACE_INLINE void
  32 TAO_Leader_Follower::set_avoid_client_leader ()
  33 {
  34   this->avoid_client_leader_ = true;
  35 }
  36
  37 ACE_INLINE bool
  38 TAO_Leader_Follower::follower_available () const
  39 {
  40   return !this->follower_set_.is_empty ();
  41 }
  42
  43 ACE_INLINE bool
  44 TAO_Leader_Follower::no_leaders_available ()
  45 {
  46   if (this->new_leader_generator_)
  47     return this->new_leader_generator_->no_leaders_available ();
  48   return false;
  49 }
  50
  51 ACE_INLINE int
  52 TAO_Leader_Follower::elect_new_leader ()
  53 {
  54   if (this->leaders_ == 0)
  55     {
  56       if (this->event_loop_threads_waiting_)
  57         {
  58           return this->event_loop_threads_condition_.broadcast ();
  59         }
  60       else if (this->follower_available ())
  61         {
  62           return this->elect_new_leader_i ();
  63         }
  64       else
  65         {
  66           this->no_leaders_available ();
  67         }
  68     }
  69   return 0;
  70 }
  71
  72 ACE_INLINE int
  73 TAO_Leader_Follower::set_event_loop_thread (ACE_Time_Value *max_wait_time)
  74 {
  75   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
  76
  77   // Make sure that there is no other client thread run the show.  If
  78   // we are the client thread running the show, then it is ok.
  79   if (this->client_thread_is_leader_ &&
  80       tss->client_leader_thread_ == 0)
  81     {
  82       int const result =
  83         this->wait_for_client_leader_to_complete (max_wait_time);
  84
  85       if (result != 0)
  86         return result;
  87     }
  88
  89   // If <event_loop_thread_> == 0 and <client_leader_thread_> == 0, we
  90   // are running the event loop for the first time.  Therefore,
  91   // increment the leaders.  Otherwise, simply increment
  92   // <event_loop_thread_> since either (a) if <event_loop_thread_> !=
  93   // 0 this is a nested call to the event loop, or (b)
  94   // <client_leader_thread_> != 0 this is a call to the event loop
  95   // while we are a client leader.
  96   if (tss->event_loop_thread_ == 0 &&
  97       tss->client_leader_thread_ == 0)
  98     ++this->leaders_;
  99
 100   ++tss->event_loop_thread_;
 101
 102   return 0;
 103 }
 104
 105 ACE_INLINE void
 106 TAO_Leader_Follower::reset_event_loop_thread_i (TAO_ORB_Core_TSS_Resources *tss)
 107 {
 108   // Always decrement <event_loop_thread_>. If <event_loop_thread_>
 109   // reaches 0 and we are not a client leader, we are done with our
 110   // duties of running the event loop. Therefore, decrement the
 111   // leaders.  Otherwise, we just got done with a nested call to the
 112   // event loop or a call to the event loop when we were the client
 113   // leader.
 114   --tss->event_loop_thread_;
 115
 116   if (tss->event_loop_thread_ == 0 &&
 117       tss->client_leader_thread_ == 0)
 118     --this->leaders_;
 119 }
 120
 121 ACE_INLINE void
 122 TAO_Leader_Follower::reset_event_loop_thread ()
 123 {
 124   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
 125   if (tss->event_loop_thread_ > 0)
 126     this->reset_event_loop_thread_i (tss);
 127 }
 128
 129 ACE_INLINE TAO_SYNCH_MUTEX &
 130 TAO_Leader_Follower::lock ()
 131 {
 132   return this->lock_;
 133 }
 134
 135 ACE_INLINE void
 136 TAO_Leader_Follower::set_upcall_thread ()
 137 {
 138   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
 139
 140   if (tss->event_loop_thread_ > 0)
 141     {
 142       ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock ());
 143       this->reset_event_loop_thread_i (tss);
 144
 145       this->elect_new_leader ();
 146     }
 147   else if (tss->client_leader_thread_ == 1)
 148     { // We are client leader thread going to handle upcall.
 149       // When we're only leading one level (which should
 150       // now always be the case since we implement leadership
 151       // abdication here) we can now give up leadership to allow a
 152       // waiting event thread to take over leaderpship
 153       ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock ());
 154       this->reset_client_leader_thread ();
 155
 156       this->elect_new_leader ();
 157     }
 158 }
 159
 160 ACE_INLINE bool
 161 TAO_Leader_Follower::leader_available () const
 162 {
 163   return this->leaders_ != 0;
 164 }
 165
 166 ACE_INLINE void
 167 TAO_Leader_Follower::set_client_leader_thread ()
 168 {
 169   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
 170   ++this->leaders_;
 171   ++this->client_thread_is_leader_;
 172   ++tss->client_leader_thread_;
 173 }
 174
 175 ACE_INLINE void
 176 TAO_Leader_Follower::reset_client_leader_thread ()
 177 {
 178   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
 179   // We may be called twice when we gave up leadership from
 180   // set_upcall_thread () if so tss->client_leader_thread_ may
 181   // already have been decremented to 0
 182   if (tss->client_leader_thread_ > 0)
 183   {
 184     --tss->client_leader_thread_;
 185     --this->leaders_;
 186     --this->client_thread_is_leader_;
 187   }
 188 }
 189
 190 ACE_INLINE bool
 191 TAO_Leader_Follower::is_client_leader_thread () const
 192 {
 193   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
 194   return tss->client_leader_thread_ != 0;
 195 }
 196
 197 ACE_INLINE void
 198 TAO_Leader_Follower::add_follower (TAO_LF_Follower *follower)
 199 {
 200   this->follower_set_.push_back (follower);
 201 }
 202
 203 ACE_INLINE void
 204 TAO_Leader_Follower::remove_follower (TAO_LF_Follower *follower)
 205 {
 206   this->follower_set_.remove (follower);
 207 }
 208
 209 ACE_INLINE ACE_Reverse_Lock<TAO_SYNCH_MUTEX> &
 210 TAO_Leader_Follower::reverse_lock ()
 211 {
 212   return this->reverse_lock_;
 213 }
 214
 215 ACE_INLINE bool
 216 TAO_Leader_Follower::has_clients () const
 217 {
 218   return this->clients_;
 219 }
 220
 221 ACE_INLINE void
 222 TAO_Leader_Follower::set_new_leader_generator(TAO_New_Leader_Generator *new_leader_generator)
 223 {
 224   this->new_leader_generator_ = new_leader_generator;
 225 }
 226
 227 // ****************************************************************
 228
 229 ACE_INLINE
 230 TAO_LF_Client_Thread_Helper::TAO_LF_Client_Thread_Helper (TAO_Leader_Follower &leader_follower)
 231   : leader_follower_ (leader_follower)
 232 {
 233   this->leader_follower_.set_client_thread ();
 234 }
 235
 236 ACE_INLINE
 237 TAO_LF_Client_Thread_Helper::~TAO_LF_Client_Thread_Helper ()
 238 {
 239   this->leader_follower_.reset_client_thread ();
 240 }
 241
 242 ACE_INLINE
 243 TAO_LF_Client_Leader_Thread_Helper::TAO_LF_Client_Leader_Thread_Helper (TAO_Leader_Follower &leader_follower)
 244   : leader_follower_ (leader_follower)
 245 {
 246   this->leader_follower_.set_client_leader_thread ();
 247 }
 248
 249 ACE_INLINE
 250 TAO_LF_Client_Leader_Thread_Helper::~TAO_LF_Client_Leader_Thread_Helper ()
 251 {
 252   this->leader_follower_.reset_client_leader_thread ();
 253 }
 254
 255 TAO_END_VERSIONED_NAMESPACE_DECL