Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

# TAO_Leader_Follower Class Reference

`#include <Leader_Follower.h>`

Collaboration diagram for TAO_Leader_Follower:

[legend]
List of all members.

## Public Methods
| TAO_Leader_Follower (TAO_ORB_Core *orb_core, TAO_New_Leader_Generator *new_leader_generator = 0)
| Constructor.
| ~TAO_Leader_Follower (void)
| Destructor.
int | 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 | reset_event_loop_thread (void)
| The current thread is not a server thread anymore, reset any flags and counters.
void | set_upcall_thread (void)
| This thread is going to perform an upcall, it will no longer be an event loop thread.
int | leader_available (void) const
| Is there any thread running as a leader?
void | set_client_thread (void)
| A server thread is making a request.
void | reset_client_thread (void)
| 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. More...
void | set_client_leader_thread (void)
| The current thread has become the leader thread in the client side leader-follower set.
void | reset_client_leader_thread (void)
| The current thread is no longer the leader thread in the client side leader-follower set.
void | set_client_leader_thread (ACE_thread_t thread_ID)
| sets the thread ID of the leader thread in the leader-follower model.
int | is_client_leader_thread (void) const
| checks if we are a leader thread.
int | elect_new_leader (void)
TAO_SYNCH_MUTEX& | lock (void)
| Get a reference to the underlying mutex.
ACE_Reverse_Lock<TAO_SYNCH_MUTEX>& | reverse_lock (void)
| Provide a pre-initialized reverse lock for the Leader/Followers set. More...
int | has_clients (void) const
| Check if there are any client threads running.
ACE_Reactor* | reactor (void)
| Accesor to the reactor.
void | no_leaders_available (void)
| Called when we are out of leaders.
Follower creation/destructions
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://ace.cs.wustl.edu/bugzilla/show_bug.cgi?id=296
TAO_LF_Follower* | allocate_follower (void)
| Allocate a new follower to the caller.
void | release_follower (TAO_LF_Follower *)
| The caller has finished using a follower.
Follower Set Operations
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.
int | follower_available (void) const
| Checks if there are any followers available. More...
## Private Types
typedef ACE_Intrusive_List< TAO_LF_Follower> | Follower_Set
| Implement the Leader/Followers set using an intrusive list.
## Private Methods
TAO_ORB_Core_TSS_Resources* | get_tss_resources (void) 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)
Follower Set Operations
int | elect_new_leader_i (void)
| Remote a follower from the Followers set and promote it to the leader role. More...
## Private Attributes
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_
Follower_Set | follower_free_list_
| Use a free list to allocate and release Follower objects.
int | leaders_
int | clients_
| Count the number of active clients, this is useful to know when to deactivate the reactor.
ACE_Reactor* | reactor_
| The reactor.
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_
| Condition variable for server threads waiting for the client leader to complete.
TAO_New_Leader_Generator* | new_leader_generator_
| Leader/Follower class uses this method to notify the system that we are out of leaders.

## Member Typedef Documentation

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

ACE_INLINE 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 )`[inline]`

| Destructor.

## Member Function Documentation

ACE_INLINE 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.

ACE_INLINE 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.

int TAO_Leader_Follower::elect_new_leader_i ( | void )`[private]`

| Remote 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.

ACE_INLINE int TAO_Leader_Follower::follower_available ( | void ) const

| Checks if there are any followers available. Returns: 1 if there follower set is not empty

ACE_INLINE TAO_ORB_Core_TSS_Resources * TAO_Leader_Follower::get_tss_resources ( | void ) const`[private]`

| Shortcut to obtain the TSS resources of the orb core.

ACE_INLINE int TAO_Leader_Follower::has_clients ( | void ) const

| Check if there are any client threads running.

ACE_INLINE int TAO_Leader_Follower::is_client_leader_thread ( | void ) const

| checks if we are a leader thread.

ACE_INLINE int TAO_Leader_Follower::leader_available ( | void ) const

| Is there any thread running as a leader?

ACE_INLINE TAO_SYNCH_MUTEX & TAO_Leader_Follower::lock ( | void )

| Get a reference to the underlying mutex.

ACE_INLINE void 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.

ACE_INLINE void TAO_Leader_Follower::remove_follower ( | TAO_LF_Follower * follower )

| Removes a follower from the leader-follower set.

ACE_INLINE 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.

ACE_INLINE void TAO_Leader_Follower::reset_event_loop_thread ( | void )

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

ACE_INLINE 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.

ACE_INLINE 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_client_leader_thread ( | ACE_thread_t thread_ID )

| sets the thread ID of the leader thread in the leader-follower model.

ACE_INLINE 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_thread ( | void )

| A server thread is making a request.

ACE_INLINE 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.

ACE_INLINE 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.

int TAO_Leader_Follower::wait_for_client_leader_to_complete ( | ACE_Time_Value * max_wait_time )`[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. Parameters:
  event | The event we wait for, the loop iterates until the event is sucessful, 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
Todo: Document this better, split the Follower code to the TAO_LF_Follower class, we probably don't need the transport object.

## Member Data Documentation

int TAO_Leader_Follower::client_thread_is_leader_`[private]`

| Is a client thread the current leader?

int TAO_Leader_Follower::clients_`[private]`

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

TAO_SYNCH_CONDITION TAO_Leader_Follower::event_loop_threads_condition_`[private]`

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

int TAO_Leader_Follower::event_loop_threads_waiting_`[private]`

| Are server threads waiting for the client leader to complete?

Follower_Set TAO_Leader_Follower::follower_free_list_`[private]`

| Use a free list to allocate and release Follower objects.

Follower_Set TAO_Leader_Follower::follower_set_`[private]`

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.

TAO_SYNCH_MUTEX TAO_Leader_Follower::lock_`[private]`

| To synchronize access to the members.

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.

TAO_ORB_Core * TAO_Leader_Follower::orb_core_`[private]`

| The orb core.

ACE_Reactor * TAO_Leader_Follower::reactor_`[private]`

| The reactor.

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:

- Leader_Follower.h
- Leader_Follower.cpp
- Leader_Follower.i