#include <Leader_Follower.h>

Collaboration diagram for TAO_Leader_Follower:

[legend]

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.

	~TAO_Leader_Follower ()
	Destructor.

int	set_event_loop_thread (ACE_Time_Value *max_wait_time)

void	reset_event_loop_thread ()

void	set_upcall_thread ()

bool	leader_available () const
	Is there any thread running as a leader?

void	set_client_thread ()
	A server thread is making a request.

void	reset_client_thread ()
	A server thread has finished is making a request.

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.

void	set_client_leader_thread ()

void	reset_client_leader_thread ()

void	set_client_leader_thread (ACE_thread_t thread_ID)

bool	is_client_leader_thread () const
	Checks if we are a leader thread.

void	set_avoid_client_leader ()

int	elect_new_leader ()

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: http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=296
TAO_LF_Follower *	allocate_follower ()
	Allocate a new follower to the caller.

void	release_follower (TAO_LF_Follower *)
	The caller has finished using a follower.

Follower Set Operations
typedef ACE_Intrusive_List< TAO_LF_Follower >	Follower_Set
	Implement the Leader/Followers set using an intrusive list.

typedef ACE_Intrusive_List< Deferred_Event >	Deferred_Event_Set
	The set of deferred event handlers.

TAO_ORB_Core *	orb_core_
	The orb core.

TAO_SYNCH_MUTEX	lock_
	To synchronize access to the members.

ACE_Reverse_Lock< TAO_SYNCH_MUTEX >	reverse_lock_
	Do protect the access to the following three members.

Follower_Set	follower_set_
	Implement the Leader/Followers set using an intrusive list.

Follower_Set	follower_free_list_
	Use a free list to allocate and release Follower objects.

int	leaders_

int	clients_

ACE_Reactor *	reactor_
	The reactor.

bool	avoid_client_leader_

int	client_thread_is_leader_
	Is a client thread the current leader?

int	event_loop_threads_waiting_
	Are server threads waiting for the client leader to complete?

TAO_SYNCH_CONDITION	event_loop_threads_condition_

TAO_New_Leader_Generator *	new_leader_generator_

Deferred_Event_Set	deferred_event_set_
	Implement the Leader/Followers set using an intrusive list.

void	add_follower (TAO_LF_Follower *follower)
	Add a new follower to the set.

void	remove_follower (TAO_LF_Follower *follower)
	Removes a follower from the leader-follower set.

bool	follower_available () const
	Checks if there are any followers available.

TAO_SYNCH_MUTEX &	lock ()
	Get a reference to the underlying mutex.

ACE_Reverse_Lock< TAO_SYNCH_MUTEX > &	reverse_lock ()

bool	has_clients () const
	Check if there are any client threads running.

ACE_Reactor *	reactor ()
	Accessor to the reactor.

bool	no_leaders_available ()
	Called when we are out of leaders.

void	set_new_leader_generator (TAO_New_Leader_Generator *new_leader_generator)
	Set the new leader generator.

int	defer_event (ACE_Event_Handler *)

TAO_ORB_Core_TSS_Resources *	get_tss_resources () const
	Shortcut to obtain the TSS resources of the orb core.

int	wait_for_client_leader_to_complete (ACE_Time_Value *max_wait_time)
	Wait for the client leader to complete.

void	reset_event_loop_thread_i (TAO_ORB_Core_TSS_Resources *tss)

int	elect_new_leader_i ()

void	resume_events ()

Detailed Description

TAO_Leader_Follower.

TAO_Leader_Follower

Member Typedef Documentation

◆ Deferred_Event_Set

typedef ACE_Intrusive_List<Deferred_Event> TAO_Leader_Follower::Deferred_Event_Set

private

The set of deferred event handlers.

◆ Follower_Set

typedef ACE_Intrusive_List<TAO_LF_Follower> TAO_Leader_Follower::Follower_Set

private

Implement the Leader/Followers set using an intrusive list.

Constructor & Destructor Documentation

◆ TAO_Leader_Follower()

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::~TAO_Leader_Follower ( )

Destructor.

Member Function Documentation

◆ add_follower()

void TAO_Leader_Follower::add_follower ( TAO_LF_Follower * follower )

Add a new follower to the set.

◆ allocate_follower()

TAO_LF_Follower * TAO_Leader_Follower::allocate_follower ( )

Allocate a new follower to the caller.

◆ defer_event()

int TAO_Leader_Follower::defer_event ( ACE_Event_Handler * eh )

Method to support deferring an event till later (f.i. in cases where transport()->wait_strategy()->can_process_upcalls() returns false).

◆ elect_new_leader()

int TAO_Leader_Follower::elect_new_leader ( )

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.

◆ elect_new_leader_i()

int TAO_Leader_Follower::elect_new_leader_i ( )

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.

◆ follower_available()

bool TAO_Leader_Follower::follower_available ( ) const

Checks if there are any followers available.

Returns: true if there follower set is not empty

◆ get_tss_resources()

TAO_ORB_Core_TSS_Resources * TAO_Leader_Follower::get_tss_resources ( ) const

private

Shortcut to obtain the TSS resources of the orb core.

◆ has_clients()

bool TAO_Leader_Follower::has_clients ( ) const

Check if there are any client threads running.

◆ is_client_leader_thread()

bool TAO_Leader_Follower::is_client_leader_thread ( ) const

Checks if we are a leader thread.

◆ leader_available()

bool TAO_Leader_Follower::leader_available ( ) const

Is there any thread running as a leader?

◆ lock()

TAO_SYNCH_MUTEX & TAO_Leader_Follower::lock ( )

Get a reference to the underlying mutex.

◆ no_leaders_available()

bool TAO_Leader_Follower::no_leaders_available ( )

Called when we are out of leaders.

◆ reactor()

ACE_Reactor * TAO_Leader_Follower::reactor ( )

Accessor to the reactor.

◆ release_follower()

void TAO_Leader_Follower::release_follower ( TAO_LF_Follower * follower )

The caller has finished using a follower.

◆ remove_follower()

void TAO_Leader_Follower::remove_follower ( TAO_LF_Follower * follower )

Removes a follower from the leader-follower set.

◆ reset_client_leader_thread()

void TAO_Leader_Follower::reset_client_leader_thread ( )

The current thread is no longer the leader thread in the client side leader-follower set.

◆ reset_client_thread()

void TAO_Leader_Follower::reset_client_thread ( )

A server thread has finished is making a request.

◆ reset_event_loop_thread()

void TAO_Leader_Follower::reset_event_loop_thread ( )

The current thread is not a server thread anymore, reset any flags and counters.

◆ reset_event_loop_thread_i()

void TAO_Leader_Follower::reset_event_loop_thread_i ( TAO_ORB_Core_TSS_Resources * tss )

private

Implement the reset_event_loop_thread() method, once the TSS resources have been acquired. Also used in the set_upcall_thread.

◆ resume_events()

void TAO_Leader_Follower::resume_events ( )

private

Method to allow the Leader_Follower to resume deferred events when it is opportune to do so.

◆ reverse_lock()

ACE_Reverse_Lock< TAO_SYNCH_MUTEX > & TAO_Leader_Follower::reverse_lock ( )

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.

◆ set_avoid_client_leader()

void TAO_Leader_Follower::set_avoid_client_leader ( )

Sets the client leader avoidance flag true. This is used with the noupcall wait strategy to allow the creation of dynamic threads when possible

◆ set_client_leader_thread() [1/2]

void TAO_Leader_Follower::set_client_leader_thread ( )

The current thread has become the leader thread in the client side leader-follower set.

◆ set_client_leader_thread() [2/2]

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

◆ set_client_thread()

void TAO_Leader_Follower::set_client_thread ( )

A server thread is making a request.

◆ set_event_loop_thread()

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.

◆ set_new_leader_generator()

void TAO_Leader_Follower::set_new_leader_generator ( TAO_New_Leader_Generator * new_leader_generator )

Set the new leader generator.

◆ set_upcall_thread()

void TAO_Leader_Follower::set_upcall_thread ( )

This thread is going to perform an upcall, it will no longer be an event loop thread.

◆ wait_for_client_leader_to_complete()

int TAO_Leader_Follower::wait_for_client_leader_to_complete ( ACE_Time_Value * max_wait_time )

private

Wait for the client leader to complete.

◆ wait_for_event()

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.

Parameters

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

Returns: Returns -1 on error, 0 or non-zero value otherwise.

Todo: Document this better, split the Follower code to the TAO_LF_Follower class, we probably don't need the transport object.

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;

Member Data Documentation

◆ avoid_client_leader_

bool TAO_Leader_Follower::avoid_client_leader_

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.

◆ client_thread_is_leader_

int TAO_Leader_Follower::client_thread_is_leader_

private

Is a client thread the current leader?

◆ clients_

int TAO_Leader_Follower::clients_

private

Count the number of active clients, this is useful to know when to deactivate the reactor

◆ deferred_event_set_

Deferred_Event_Set TAO_Leader_Follower::deferred_event_set_

private

Implement the Leader/Followers set using an intrusive list.

◆ event_loop_threads_condition_

TAO_SYNCH_CONDITION TAO_Leader_Follower::event_loop_threads_condition_

private

Condition variable for server threads waiting for the client leader to complete.

◆ event_loop_threads_waiting_

int TAO_Leader_Follower::event_loop_threads_waiting_

private

Are server threads waiting for the client leader to complete?

◆ follower_free_list_

Follower_Set TAO_Leader_Follower::follower_free_list_

private

Use a free list to allocate and release Follower objects.

◆ follower_set_

Follower_Set TAO_Leader_Follower::follower_set_

private

Implement the Leader/Followers set using an intrusive list.

◆ leaders_

int TAO_Leader_Follower::leaders_

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.

◆ lock_

TAO_SYNCH_MUTEX TAO_Leader_Follower::lock_

private

To synchronize access to the members.

◆ new_leader_generator_

TAO_New_Leader_Generator* TAO_Leader_Follower::new_leader_generator_

private

Leader/Follower class uses this method to notify the system that we are out of leaders.

◆ orb_core_

TAO_ORB_Core* TAO_Leader_Follower::orb_core_

private

The orb core.

◆ reactor_

ACE_Reactor* TAO_Leader_Follower::reactor_

private

The reactor.

◆ reverse_lock_

ACE_Reverse_Lock<TAO_SYNCH_MUTEX> TAO_Leader_Follower::reverse_lock_

private

Do protect the access to the following three members.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Follower Set Operations

Detailed Description

Member Typedef Documentation

◆ Deferred_Event_Set

◆ Follower_Set

Constructor & Destructor Documentation

◆ TAO_Leader_Follower()

◆ ~TAO_Leader_Follower()

Member Function Documentation

◆ add_follower()

◆ allocate_follower()

◆ defer_event()

◆ elect_new_leader()

◆ elect_new_leader_i()

◆ follower_available()

◆ get_tss_resources()

◆ has_clients()

◆ is_client_leader_thread()

◆ leader_available()

◆ lock()

◆ no_leaders_available()

◆ reactor()

◆ release_follower()

◆ remove_follower()

◆ reset_client_leader_thread()

◆ reset_client_thread()

◆ reset_event_loop_thread()

◆ reset_event_loop_thread_i()

◆ resume_events()

◆ reverse_lock()

◆ set_avoid_client_leader()

◆ set_client_leader_thread() [1/2]

◆ set_client_leader_thread() [2/2]

◆ set_client_thread()

◆ set_event_loop_thread()

◆ set_new_leader_generator()

◆ set_upcall_thread()

◆ wait_for_client_leader_to_complete()

◆ wait_for_event()

Member Data Documentation

◆ avoid_client_leader_

◆ client_thread_is_leader_

◆ clients_

◆ deferred_event_set_

◆ event_loop_threads_condition_

◆ event_loop_threads_waiting_

◆ follower_free_list_

◆ follower_set_

◆ leaders_

◆ lock_

◆ new_leader_generator_

◆ orb_core_

◆ reactor_

◆ reverse_lock_