ACE_TP_Reactor Class Reference

Specialization of ACE_Select_Reactor to support thread-pool based event dispatching. More...

#include <TP_Reactor.h>

Inheritance diagram for ACE_TP_Reactor:

Collaboration diagram for ACE_TP_Reactor:

List of all members.

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)

virtual int owner (ACE_thread_t *t_id)

Return the thread ID of the current Leader.

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 &)

Detailed Description

Specialization of ACE_Select_Reactor to support thread-pool based event dispatching.

One of the shortcomings of the ACE_Select_Reactor is that it does not support a thread pool-based event dispatching model, similar to the one in ACE_WFMO_Reactor. In ACE_Select_Reactor, only thread can call handle_events() at any given time. ACE_TP_Reactor removes this short-coming.

ACE_TP_Reactor is a specialization of ACE_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 which was just activated, suspending it for further I/O activities, releasing the internal lock (so that another thread can start waiting in the event loop) and then dispatching the event's handler outside the scope of the reactor lock. After the event handler has been dispatched the event handler is resumed for further I/O activity.

This reactor implementation 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 loop. Note that I/O-processing callback code in event handlers (e.g. handle_input()) does not have to be modified or made thread-safe for this reactor. This is because before an I/O event is dispatched to an event handler, the handler is suspended; it is resumed by the reactor after the upcall completes. Therefore, multiple I/O events will not be made to one event handler multiple threads simultaneously. This suspend/resume protection does not apply to either timers scheduled with the reactor or to notifications requested via the reactor. When using timers and/or notifications you must provide proper protection for your class in the context of multiple threads.

Constructor & Destructor Documentation

ACE_TP_Reactor::ACE_TP_Reactor	(	ACE_Sig_Handler *	sh = `0`,
		ACE_Timer_Queue *	tq = `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...

Member Function Documentation

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 events that were dispatched; 0 if the max_wait_time elapsed without dispatching any handlers, or -1 if an error occurs (check errno for more information).

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]`

The ACE_TP_Reactor implementation does not have a single owner thread. Attempts to set the owner explicitly are ignored. The reported owner thread is the current Leader in the pattern.

Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.

int ACE_TP_Reactor::owner ( ACE_thread_t * t_id ) [virtual]

Return the thread ID of the current Leader.

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]`

Template method from the base class.

Reimplemented from ACE_Select_Reactor_Impl.

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]

Member Data Documentation

ACE_TP_Reactor::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.

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


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)
virtual int	owner (ACE_thread_t *t_id)
	Return the thread ID of the current Leader.
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 &)