TAO
2.1.8
|
#include <Leader_Follower.h>
Classes | |
class | Deferred_Event |
Class used to register deferred event handlers. More... | |
Public Member Functions | |
TAO_Leader_Follower (TAO_ORB_Core *orb_core, TAO_New_Leader_Generator *new_leader_generator=0) | |
Constructor. More... | |
~TAO_Leader_Follower (void) | |
Destructor. More... | |
int | set_event_loop_thread (ACE_Time_Value *max_wait_time) |
void | reset_event_loop_thread (void) |
void | set_upcall_thread (void) |
bool | leader_available (void) const |
Is there any thread running as a leader? More... | |
void | set_client_thread (void) |
A server thread is making a request. More... | |
void | reset_client_thread (void) |
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 (void) |
void | reset_client_leader_thread (void) |
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... | |
void | set_avoid_client_leader (void) |
int | elect_new_leader (void) |
TAO_SYNCH_MUTEX & | lock (void) |
Get a reference to the underlying mutex. More... | |
ACE_Reverse_Lock < TAO_SYNCH_MUTEX > & | reverse_lock (void) |
bool | has_clients (void) const |
Check if there are any client threads running. More... | |
ACE_Reactor * | reactor (void) |
Accesor to the reactor. More... | |
bool | no_leaders_available (void) |
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 *) |
Follower creation/destruction | |
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... | |
Private Types | |
typedef ACE_Intrusive_List < TAO_LF_Follower > | Follower_Set |
Implement the Leader/Followers set using an intrusive list. More... | |
typedef ACE_Intrusive_List < Deferred_Event > | Deferred_Event_Set |
The set of deferred event handlers. More... | |
Private Member Functions | |
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) |
void | resume_events () |
Private Attributes | |
TAO_ORB_Core * | orb_core_ |
The orb core. More... | |
TAO_SYNCH_MUTEX | lock_ |
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... | |
Follower_Set | follower_set_ |
Follower_Set | follower_free_list_ |
Use a free list to allocate and release Follower objects. More... | |
int | leaders_ |
int | clients_ |
ACE_Reactor * | reactor_ |
The reactor. More... | |
bool | avoid_client_leader_ |
int | client_thread_is_leader_ |
Is a client thread the current leader? More... | |
int | event_loop_threads_waiting_ |
Are server threads waiting for the client leader to complete? More... | |
TAO_SYNCH_CONDITION | event_loop_threads_condition_ |
TAO_New_Leader_Generator * | new_leader_generator_ |
Deferred_Event_Set | deferred_event_set_ |
Follower Set Operations | |
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... | |
int | elect_new_leader_i (void) |
|
private |
The set of deferred event handlers.
|
private |
Implement the Leader/Followers set using an intrusive list.
TAO_Leader_Follower::TAO_Leader_Follower | ( | TAO_ORB_Core * | orb_core, |
TAO_New_Leader_Generator * | new_leader_generator = 0 |
||
) |
Constructor.
TAO_Leader_Follower::~TAO_Leader_Follower | ( | void | ) |
Destructor.
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).
int TAO_Leader_Follower::elect_new_leader | ( | void | ) |
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.
|
private |
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.
bool TAO_Leader_Follower::follower_available | ( | void | ) | const |
Checks if there are any followers available.
|
private |
Shortcut to obtain the TSS resources of the orb core.
bool TAO_Leader_Follower::has_clients | ( | void | ) | const |
Check if there are any client threads running.
bool TAO_Leader_Follower::is_client_leader_thread | ( | void | ) | const |
Checks if we are a leader thread.
bool TAO_Leader_Follower::leader_available | ( | void | ) | const |
Is there any thread running as a leader?
TAO_SYNCH_MUTEX & TAO_Leader_Follower::lock | ( | void | ) |
Get a reference to the underlying mutex.
bool TAO_Leader_Follower::no_leaders_available | ( | void | ) |
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.
void TAO_Leader_Follower::reset_client_leader_thread | ( | void | ) |
The current thread is no longer the leader thread in the client side leader-follower set.
void TAO_Leader_Follower::reset_client_thread | ( | void | ) |
A server thread has finished is making a request.
void TAO_Leader_Follower::reset_event_loop_thread | ( | void | ) |
The current thread is not a server thread anymore, reset any flags and counters.
|
private |
Implement the reset_event_loop_thread() method, once the TSS resources have been acquired. Also used in the set_upcall_thread.
|
private |
Method to allow the Leader_Follower to resume deferred events when it is opportune to do so.
ACE_Reverse_Lock< TAO_SYNCH_MUTEX > & TAO_Leader_Follower::reverse_lock | ( | void | ) |
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.
void TAO_Leader_Follower::set_avoid_client_leader | ( | void | ) |
Sets the client leader avoidance flag true. This is used with the noupcall wait strategy to allow the creation of dynamic threads when possible
void TAO_Leader_Follower::set_client_leader_thread | ( | void | ) |
The current thread has become the leader thread in the client side leader-follower set.
void TAO_Leader_Follower::set_client_leader_thread | ( | ACE_thread_t | thread_ID | ) |
Sets the thread ID of the leader thread in the leader-follower model
void TAO_Leader_Follower::set_client_thread | ( | void | ) |
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.
void TAO_Leader_Follower::set_upcall_thread | ( | void | ) |
This thread is going to perform an upcall, it will no longer be an event loop thread.
|
private |
Wait for the client leader to complete.
int TAO_Leader_Follower::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.
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;
|
private |
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.
|
private |
Is a client thread the current leader?
|
private |
Count the number of active clients, this is useful to know when to deactivate the reactor
|
private |
|
private |
Condition variable for server threads waiting for the client leader to complete.
|
private |
Are server threads waiting for the client leader to complete?
|
private |
Use a free list to allocate and release Follower objects.
|
private |
|
private |
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.
|
private |
To synchronize access to the members.
|
private |
Leader/Follower class uses this method to notify the system that we are out of leaders.
|
private |
The orb core.
|
private |
The reactor.
|
private |
Do protect the access to the following three members.