#include <TP_Reactor.h>
Inheritance diagram for ACE_TP_Reactor:
Public Member Functions | |
ACE_TP_Reactor (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int mask_signals=1, int s_queue=ACE_Select_Reactor_Token::FIFO) | |
Initialize ACE_TP_Reactor with the default size. | |
ACE_TP_Reactor (size_t max_number_of_handles, int restart=0, ACE_Sig_Handler *sh=0, ACE_Timer_Queue *tq=0, int mask_signals=1, int s_queue=ACE_Select_Reactor_Token::FIFO) | |
virtual int | handle_events (ACE_Time_Value *max_wait_time=0) |
virtual int | handle_events (ACE_Time_Value &max_wait_time) |
virtual int | resumable_handler (void) |
virtual int | owner (ACE_thread_t n_id, ACE_thread_t *o_id=0) |
Set the new owner of the thread and return the old owner. | |
virtual int | owner (ACE_thread_t *t_id) |
Return the current owner of the thread. | |
Static Public Member Functions | |
static void | no_op_sleep_hook (void *) |
Called from handle events. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Member Functions | |
virtual void | clear_dispatch_mask (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
Template method from the base class. | |
int | dispatch_i (ACE_Time_Value *max_wait_time, ACE_TP_Token_Guard &guard) |
Dispatch just 1 signal, timer, notification handlers. | |
int | get_event_for_dispatching (ACE_Time_Value *max_wait_time) |
int | handle_timer_events (int &event_count, ACE_TP_Token_Guard &g) |
Handle timer events. | |
int | handle_notify_events (int &event_count, ACE_TP_Token_Guard &g) |
Handle notify events. | |
int | handle_socket_events (int &event_count, ACE_TP_Token_Guard &g) |
handle socket events | |
virtual void | notify_handle (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Handle_Set &, ACE_Event_Handler *eh, ACE_EH_PTMF callback) |
This method shouldn't get called. | |
Private Member Functions | |
ACE_HANDLE | get_notify_handle (void) |
int | get_socket_event_info (ACE_EH_Dispatch_Info &info) |
Get socket event dispatch information. | |
int | dispatch_socket_event (ACE_EH_Dispatch_Info &dispatch_info) |
void | clear_handle_read_set (ACE_HANDLE handle) |
Clear the handle from the read_set. | |
int | post_process_socket_event (ACE_EH_Dispatch_Info &dispatch_info, int status) |
ACE_TP_Reactor (const ACE_TP_Reactor &) | |
Deny access since member-wise won't work... | |
ACE_TP_Reactor & | operator= (const ACE_TP_Reactor &) |
One of the short comings of the Select_Reactor in ACE is that it did not support a thread pool based event dispatching model, similar to the one in WFMO_Reactor. In Select_Reactor, only thread can be blocked in <handle_events> at any given time.
A new Reactor has been added to ACE that removes this short-coming. TP_Reactor is a specialization of Select Reactor to support thread-pool based event dispatching. This Reactor takes advantage of the fact that events reported by <select> are persistent if not acted upon immediately. It works by remembering the event handler that just got activated, releasing the internal lock (so that some other thread can start waiting in the event loop) and then dispatching the event handler outside the context of the Reactor lock. After the event handler has been dispatched the event handler is resumed again. Don't call remove_handler() from the handle_x methods, instead return -1.
This Reactor is best suited for situations when the callbacks to event handlers can take arbitrarily long and/or a number of threads are available to run the event loops. Note that callback code in Event Handlers (e.g. Event_Handler::handle_input) does not have to be modified or made thread-safe for this Reactor. This is because an activated Event Handler is suspended in the Reactor before the upcall is made and resumed after the upcall completes. Therefore, one Event Handler cannot be called by multiple threads simultaneously.
ACE_TP_Reactor::ACE_TP_Reactor | ( | ACE_Sig_Handler * | = 0 , |
|
ACE_Timer_Queue * | = 0 , |
|||
int | mask_signals = 1 , |
|||
int | s_queue = ACE_Select_Reactor_Token::FIFO | |||
) |
Initialize ACE_TP_Reactor with the default size.
ACE_TP_Reactor::ACE_TP_Reactor | ( | size_t | max_number_of_handles, | |
int | restart = 0 , |
|||
ACE_Sig_Handler * | sh = 0 , |
|||
ACE_Timer_Queue * | tq = 0 , |
|||
int | mask_signals = 1 , |
|||
int | s_queue = ACE_Select_Reactor_Token::FIFO | |||
) |
Initialize the ACE_TP_Reactor to manage max_number_of_handles. If restart is non-0 then the ACE_Reactor's handle_events()
method will be restarted automatically when EINTR
occurs. If sh or tq are non-0 they are used as the signal handler and timer queue, respectively.
ACE_TP_Reactor::ACE_TP_Reactor | ( | const ACE_TP_Reactor & | ) | [private] |
Deny access since member-wise won't work...
int ACE_TP_Reactor::handle_events | ( | ACE_Time_Value * | max_wait_time = 0 |
) | [virtual] |
This event loop driver that blocks for max_wait_time before returning. It will return earlier if timer events, I/O events, or signal events occur. Note that max_wait_time can be 0, in which case this method blocks indefinitely until events occur.
max_wait_time is decremented to reflect how much time this call took. For instance, if a time value of 3 seconds is passed to handle_events and an event occurs after 2 seconds, max_wait_time will equal 1 second. This can be used if an application wishes to handle events for some fixed amount of time.
Returns the total number of ACE_Event_Handlers that were dispatched, 0 if the max_wait_time elapsed without dispatching any handlers, or -1 if something goes wrong.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
int ACE_TP_Reactor::handle_events | ( | ACE_Time_Value & | max_wait_time | ) | [virtual] |
This method is just like the one above, except the max_wait_time value is a reference and can therefore never be NULL.
Current <alertable_handle_events> is identical to <handle_events>.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
int ACE_TP_Reactor::resumable_handler | ( | void | ) | [virtual] |
Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. The TP reactor has can allow applications to resume handles. So return a positive value.
Reimplemented from ACE_Select_Reactor_Impl.
ACE_INLINE void ACE_TP_Reactor::no_op_sleep_hook | ( | void * | ) | [static] |
Called from handle events.
int ACE_TP_Reactor::owner | ( | ACE_thread_t | n_id, | |
ACE_thread_t * | o_id = 0 | |||
) | [virtual] |
Set the new owner of the thread and return the old owner.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
int ACE_TP_Reactor::owner | ( | ACE_thread_t * | t_id | ) | [virtual] |
Return the current owner of the thread.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
ACE_INLINE void ACE_TP_Reactor::clear_dispatch_mask | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask | |||
) | [protected, virtual] |
int ACE_TP_Reactor::dispatch_i | ( | ACE_Time_Value * | max_wait_time, | |
ACE_TP_Token_Guard & | guard | |||
) | [protected] |
Dispatch just 1 signal, timer, notification handlers.
int ACE_TP_Reactor::get_event_for_dispatching | ( | ACE_Time_Value * | max_wait_time | ) | [protected] |
Get the event that needs dispatching. It could be either a signal, timer, notification handlers or return possibly 1 I/O handler for dispatching. In the most common use case, this would return 1 I/O handler for dispatching
int ACE_TP_Reactor::handle_timer_events | ( | int & | event_count, | |
ACE_TP_Token_Guard & | g | |||
) | [protected] |
Handle timer events.
int ACE_TP_Reactor::handle_notify_events | ( | int & | event_count, | |
ACE_TP_Token_Guard & | g | |||
) | [protected] |
Handle notify events.
int ACE_TP_Reactor::handle_socket_events | ( | int & | event_count, | |
ACE_TP_Token_Guard & | g | |||
) | [protected] |
handle socket events
void ACE_TP_Reactor::notify_handle | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
ACE_Handle_Set & | , | |||
ACE_Event_Handler * | eh, | |||
ACE_EH_PTMF | callback | |||
) | [protected, virtual] |
This method shouldn't get called.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
ACE_HANDLE ACE_TP_Reactor::get_notify_handle | ( | void | ) | [private] |
Get the handle of the notify pipe from the ready set if there is an event in the notify pipe.
int ACE_TP_Reactor::get_socket_event_info | ( | ACE_EH_Dispatch_Info & | info | ) | [private] |
Get socket event dispatch information.
int ACE_TP_Reactor::dispatch_socket_event | ( | ACE_EH_Dispatch_Info & | dispatch_info | ) | [private] |
Notify the appropriate <callback> in the context of the <eh> associated with <handle> that a particular event has occurred.
ACE_INLINE void ACE_TP_Reactor::clear_handle_read_set | ( | ACE_HANDLE | handle | ) | [private] |
Clear the handle from the read_set.
int ACE_TP_Reactor::post_process_socket_event | ( | ACE_EH_Dispatch_Info & | dispatch_info, | |
int | status | |||
) | [private] |
ACE_TP_Reactor& ACE_TP_Reactor::operator= | ( | const ACE_TP_Reactor & | ) | [private] |
Declare the dynamic allocation hooks.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.