|Class used to register deferred event handlers. More...|
|TAO_Leader_Follower (TAO_ORB_Core *orb_core, TAO_New_Leader_Generator *new_leader_generator=0)|
|int||set_event_loop_thread (ACE_Time_Value *max_wait_time)|
|bool||leader_available (void) const|
|Is there any thread running as a leader? More...|
|A server thread is making a request. More...|
|A server thread has finished is making a request. More...|
|int||wait_for_event (TAO_LF_Event *event, TAO_Transport *transport, ACE_Time_Value *max_wait_time)|
|Wait on the Leader/Followers loop until one event happens. More...|
|void||set_client_leader_thread (ACE_thread_t thread_ID)|
|bool||is_client_leader_thread (void) const|
|Checks if we are a leader thread. More...|
|TAO_SYNCH_MUTEX &||lock (void)|
|Get a reference to the underlying mutex. More...|
< TAO_SYNCH_MUTEX > &
|bool||has_clients (void) const|
|Check if there are any client threads running. More...|
|ACE_Reactor *||reactor (void)|
|Accesor to the reactor. More...|
|Called when we are out of leaders. More...|
|void||set_new_leader_generator (TAO_New_Leader_Generator *new_leader_generator)|
|Set the new leader generator. More...|
|int||defer_event (ACE_Event_Handler *)|
The Leader/Followers set acts as a factory for the Follower objects. Followers are used to represent a thread blocked waiting in the Follower set.
The Leader/Followers abstraction keeps a list of the waiting followers, so it can wake up one when the leader thread stops handling events.
For performance reasons the Leader/Followers set uses a pool (or free-list) to keep Follower objects unattached to any thread. It could be tempting to use TSS to keep such followers, after all a thread can only need one such Follower object, however, that does not work with multiple Leader/Followers sets, consult this bug report for more details:
|TAO_LF_Follower *||allocate_follower (void)|
|Allocate a new follower to the caller. More...|
|void||release_follower (TAO_LF_Follower *)|
|The caller has finished using a follower. More...|
< TAO_LF_Follower >
|Implement the Leader/Followers set using an intrusive list. More...|
< Deferred_Event >
|The set of deferred event handlers. More...|
|TAO_ORB_Core_TSS_Resources *||get_tss_resources (void) const|
|Shortcut to obtain the TSS resources of the orb core. More...|
|int||wait_for_client_leader_to_complete (ACE_Time_Value *max_wait_time)|
|Wait for the client leader to complete. More...|
|void||reset_event_loop_thread_i (TAO_ORB_Core_TSS_Resources *tss)|
|The orb core. More...|
|To synchronize access to the members. More...|
|ACE_Reverse_Lock< TAO_SYNCH_MUTEX >||reverse_lock_|
|Do protect the access to the following three members. More...|
|Use a free list to allocate and release Follower objects. More...|
|The reactor. More...|
|Is a client thread the current leader? More...|
|Are server threads waiting for the client leader to complete? More...|
|void||add_follower (TAO_LF_Follower *follower)|
|Add a new follower to the set. More...|
|void||remove_follower (TAO_LF_Follower *follower)|
|Removes a follower from the leader-follower set. More...|
|bool||follower_available (void) const|
|Checks if there are any followers available. More...|
The set of deferred event handlers.
Implement the Leader/Followers set using an intrusive list.
|TAO_New_Leader_Generator *||new_leader_generator =
|void TAO_Leader_Follower::add_follower||(||TAO_LF_Follower *||follower||)|
Add a new follower to the set.
|TAO_LF_Follower * TAO_Leader_Follower::allocate_follower||(||void||)|
Allocate a new follower to the caller.
|int TAO_Leader_Follower::defer_event||(||ACE_Event_Handler *||eh||)|
Method to support deffering an event till later (f.i. in cases where transport()->wait_strategy()->can_process_upcalls() returns false).
A leader thread is relinquishing its role, unless there are more leader threads running pick up a follower (if there is any) to play the leader role.
Remove a follower from the Followers set and promote it to the leader role. This is a helper routine for elect_new_leader(), after verifying that all the pre-conditions are satisfied the Follower set is changed and the promoted Follower is signaled.
Checks if there are any followers available.
Shortcut to obtain the TSS resources of the orb core.
Check if there are any client threads running.
Checks if we are a leader thread.
Is there any thread running as a leader?
|TAO_SYNCH_MUTEX & TAO_Leader_Follower::lock||(||void||)|
Get a reference to the underlying mutex.
Called when we are out of leaders.
|ACE_Reactor * TAO_Leader_Follower::reactor||(||void||)|
Accesor to the reactor.
|void TAO_Leader_Follower::release_follower||(||TAO_LF_Follower *||follower||)|
The caller has finished using a follower.
|void TAO_Leader_Follower::remove_follower||(||TAO_LF_Follower *||follower||)|
Removes a follower from the leader-follower set.
The current thread is no longer the leader thread in the client side leader-follower set.
A server thread has finished is making a request.
The current thread is not a server thread anymore, reset any flags and counters.
Implement the reset_event_loop_thread() method, once the TSS resources have been acquired. Also used in the set_upcall_thread.
Method to allow the Leader_Follower to resume deferred events when it is opportune to do so.
Provide a pre-initialized reverse lock for the Leader/Followers set. The Leader/Followers set mutex must be release during some long running operations. This helper class simplifies the process of releasing and reacquiring said mutex.
Sets the client leader avoidance flag true. This is used with the noupcall wait strategy to allow the creation of dynamic threads when possible
The current thread has become the leader thread in the client side leader-follower set.
Sets the thread ID of the leader thread in the leader-follower model
A server thread is making a request.
|int TAO_Leader_Follower::set_event_loop_thread||(||ACE_Time_Value *||max_wait_time||)|
The current thread has become a server thread (i.e. called ORB::run), update any flags and counters.
|void TAO_Leader_Follower::set_new_leader_generator||(||TAO_New_Leader_Generator *||new_leader_generator||)|
Set the new leader generator.
This thread is going to perform an upcall, it will no longer be an event loop thread.
Wait for the client leader to complete.
|int TAO_Leader_Follower::wait_for_event||(||TAO_LF_Event *||event,|
Wait on the Leader/Followers loop until one event happens.
|event||The event we wait for, the loop iterates until the event is successful, or it fails due to timeout, and error or a connection closed.|
|transport||The transport attached to the event|
|max_wait_time||Limit the time spent on the loop|
There should be no reason to reset the value of result here. If there was an error in handle_events () that the leader saw, I (Bala) believe it should be propagated to the clients. result = 0;
Flag to indicate that it is preferable to start a new thread, if possible rather than become a client leader. In particular when using the no-upcall wait strategy along with the dynamic thread pool, this is the case. It is still possible for a client leader to emerge in the case when no additional threads may be generated.
Is a client thread the current leader?
Count the number of active clients, this is useful to know when to deactivate the reactor
Condition variable for server threads waiting for the client leader to complete.
Are server threads waiting for the client leader to complete?
Use a free list to allocate and release Follower objects.
Count the number of active leaders. There could be many leaders in the thread pool (i.e. calling ORB::run), and the same leader could show up multiple times as it receives nested upcalls and sends more requests.
To synchronize access to the members.
Leader/Follower class uses this method to notify the system that we are out of leaders.
The orb core.
Do protect the access to the following three members.