ACE_Dev_Poll_Reactor Class Reference

A `/dev/poll' or `/dev/epoll' based Reactor implemenatation. More...

#include <Dev_Poll_Reactor.h>

Inheritance diagram for ACE_Dev_Poll_Reactor:

[legend]Collaboration diagram for ACE_Dev_Poll_Reactor:

[legend]List of all members.

Public Member Functions
	ACE_Dev_Poll_Reactor (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *notify=0, int mask_signals=1, int s_queue=ACE_DEV_POLL_TOKEN::FIFO)
	Initialize ACE_Dev_Poll_Reactor with the default size.
	ACE_Dev_Poll_Reactor (size_t size, int restart=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *notify=0, int mask_signals=1, int s_queue=ACE_DEV_POLL_TOKEN::FIFO)
	Initialize ACE_Dev_Poll_Reactor with size size.
virtual	~ACE_Dev_Poll_Reactor (void)
	Close down and release all resources.
virtual int	open (size_t size, int restart=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *=0)
	Initialization.
virtual int	current_info (ACE_HANDLE handle, size_t &)
virtual int	set_sig_handler (ACE_Sig_Handler *signal_handler)
	Use a user specified signal handler instead.
virtual int	timer_queue (ACE_Timer_Queue *tq)
	Set a user-specified timer queue.
virtual ACE_Timer_Queue *	timer_queue (void) const
virtual int	close (void)
	Close down and release all resources.
virtual int	work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
virtual int	handle_events (ACE_Time_Value *max_wait_time=0)
virtual int	alertable_handle_events (ACE_Time_Value *max_wait_time=0)
virtual int	handle_events (ACE_Time_Value &max_wait_time)
virtual int	alertable_handle_events (ACE_Time_Value &max_wait_time)
virtual int	deactivated (void)
virtual void	deactivate (int do_stop)
virtual int	register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0)
virtual int	register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0)
virtual int	remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
	Removes event_handler.
virtual int	remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask)
virtual int	remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask mask)
virtual int	remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=0, int sigkey=-1)
virtual int	remove_handler (const ACE_Sig_Set &sigset)
	Calls for every signal in .
virtual int	suspend_handler (ACE_Event_Handler *event_handler)
virtual int	suspend_handler (ACE_HANDLE handle)
	Suspend handle temporarily.
virtual int	suspend_handler (const ACE_Handle_Set &handles)
	Suspend all handles in handle set temporarily.
virtual int	suspend_handlers (void)
	Suspend all handles temporarily.
virtual int	resume_handler (ACE_Event_Handler *event_handler)
virtual int	resume_handler (ACE_HANDLE handle)
	Resume handle.
virtual int	resume_handler (const ACE_Handle_Set &handles)
	Resume all handles in handle set.
virtual int	resume_handlers (void)
	Resume all handles.
virtual int	resumable_handler (void)
virtual int	uses_event_associations (void)
virtual long	schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval=ACE_Time_Value::zero)
virtual int	reset_timer_interval (long timer_id, const ACE_Time_Value &interval)
virtual int	cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1)
virtual int	cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1)
virtual int	schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added)
virtual int	schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added)
virtual int	cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared)
	Clear from the 's entry.
virtual int	cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared)
	Clear from the 's entry.
virtual int	notify (ACE_Event_Handler *event_handler=0, ACE_Reactor_Mask mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0)
virtual void	max_notify_iterations (int)
virtual int	max_notify_iterations (void)
virtual int	purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual ACE_Event_Handler *	find_handler (ACE_HANDLE handle)
virtual int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
virtual int	handler (int signum, ACE_Event_Handler **=0)
virtual int	initialized (void)
virtual size_t	size (void) const
virtual ACE_Lock &	lock (void)
	Returns a reference to the Reactor's internal lock.
virtual void	wakeup_all_threads (void)
	Wake up all threads waiting in the event loop.
virtual int	owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0)
	Transfers ownership of Reactor_Impl to the new_owner.
virtual int	owner (ACE_thread_t *owner)
	Return the ID of the "owner" thread.
virtual int	restart (void)
	Get the existing restart value.
virtual int	restart (int r)
	Set a new value for restart and return the original value.
virtual void	requeue_position (int)
	Set position of the owner thread.
virtual int	requeue_position (void)
	Get position of the owner thread.
virtual void	dump (void) const
	Dump the state of an object.
Low-level wait_set mask manipulation methods
Low-level methods to manipulate the event/reactor mask associated with a handle and event handler when polling for events. The "interest set," i.e. the wait set, can be directly manipulated with these methods.
virtual int	mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
virtual int	mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
Low-level ready_set mask manipulation methods
These methods are unimplemented.
virtual int	ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
virtual int	ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops)
	GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
int	work_pending_i (ACE_Time_Value *max_wait_time)
	Non-locking version of wait_pending().
int	handle_events_i (ACE_Time_Value *max_wait_time, Token_Guard &guard)
int	upcall (ACE_Event_Handler *event_handler, int(ACE_Event_Handler::*callback)(ACE_HANDLE), ACE_HANDLE handle)
	Perform the upcall with the given event handler method.
int	dispatch (Token_Guard &guard)
int	dispatch_timer_handler (Token_Guard &guard)
int	dispatch_io_event (Token_Guard &guard)
int	register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
	Register the given event handler with the reactor.
int	remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask mask)
int	suspend_handler_i (ACE_HANDLE handle)
	Temporarily remove the given handle from the "interest set.".
int	resume_handler_i (ACE_HANDLE handle)
int	mask_ops_i (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
short	reactor_mask_to_poll_event (ACE_Reactor_Mask mask)
	Convert a reactor mask to its corresponding poll() event mask.
Protected Attributes
bool	initialized_
	Has the reactor been initialized.
ACE_HANDLE	poll_fd_
size_t	size_
epoll_event *	events_
	Table of event structures to be filled by epoll_wait:.
epoll_event *	start_pevents_
epoll_event *	end_pevents_
	The last element in the event array plus one.
sig_atomic_t	deactivated_
ACE_Dev_Poll_Reactor_Token	token_
	Lock used for synchronization of reactor state.
ACE_Lock_Adapter< ACE_Dev_Poll_Reactor_Token >	lock_adapter_
	Adapter used to return internal lock to outside world.
ACE_Dev_Poll_Reactor_Handler_Repository	handler_rep_
	The repository that contains all registered event handlers.
ACE_Timer_Queue *	timer_queue_
	Defined as a pointer to allow overriding by derived classes...
int	delete_timer_queue_
ACE_Sig_Handler *	signal_handler_
	Handle signals without requiring global/static variables.
int	delete_signal_handler_
ACE_Reactor_Notify *	notify_handler_
int	delete_notify_handler_
int	mask_signals_
int	restart_

---

Detailed Description

A `/dev/poll' or `/dev/epoll' based Reactor implemenatation.

Attention:

This reactor is experimental.

The ACE_Dev_Poll_Reactor uses the `/dev/poll' or '/dev/epoll' character devices to demultiplex events on a given set of file descriptors. Unlike select(), `/dev/poll' and `/dev/epoll' have no hard-coded limit on the number of file descriptors that may be handled at any given time. As such, the ACE_Dev_Poll_Reactor can generally handle a much larger number of file descriptors than select() -based reactors. Furthermore, since `/dev/poll' and `/dev/epoll' both return a set of file descriptors that are active, there is no need to "walk" the set of file descriptors to determine which ones are active, such as what is done with the select() and poll() system calls. All returned file descriptors are active. This makes event dispatching very efficient.

Note:

In general, this reactor may only be used to demultiplex events on sockets. Demultiplexing events on pipes, for example may not work. This is due to a limitation in the underlying `/dev/poll' device driver.

It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. However, the timeout resolution for timers is independent of the reactors timeout resolution. As such, it may be possible to achieve sub-millisecond timeout resolutions for timers but that is entirely platform dependent.

Definition at line 474 of file Dev_Poll_Reactor.h.

---

Constructor & Destructor Documentation

ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor (  ACE_Sig_Handler *  = 0, ACE_Timer_Queue *  = 0, int  disable_notify_pipe = 0, ACE_Reactor_Notify *  notify = 0, int  mask_signals = 1, int  s_queue = ACE_DEV_POLL_TOKEN::FIFO )

Initialize ACE_Dev_Poll_Reactor with the default size. The default size for the ACE_Dev_Poll_Reactor is the maximum number of open file descriptors for the process. Definition at line 727 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_Timer_Queue, ACE_TRACE, LM_ERROR, and open(). : initialized_ (false) , poll_fd_ (ACE_INVALID_HANDLE) , size_ (0) // , ready_set_ () #if defined (ACE_HAS_EVENT_POLL) , events_ (0) , start_pevents_ (0) , end_pevents_ (0) #else , dp_fds_ (0) , start_pfds_ (0) , end_pfds_ (0) #endif /* ACE_HAS_EVENT_POLL */ , deactivated_ (0) , token_ (*this, s_queue) , lock_adapter_ (token_) , timer_queue_ (0) , delete_timer_queue_ (0) , signal_handler_ (0) , delete_signal_handler_ (0) , notify_handler_ (0) , delete_notify_handler_ (0) , mask_signals_ (mask_signals) , restart_ (0) { ACE_TRACE ("ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor"); if (this->open (ACE::max_handles (), 0, sh, tq, disable_notify_pipe, notify) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Dev_Poll_Reactor::open ") ACE_LIB_TEXT ("failed inside ") ACE_LIB_TEXT ("ACE_Dev_Poll_Reactor::CTOR"))); }

ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor (  size_t  size, int  restart = 0, ACE_Sig_Handler *  = 0, ACE_Timer_Queue *  = 0, int  disable_notify_pipe = 0, ACE_Reactor_Notify *  notify = 0, int  mask_signals = 1, int  s_queue = ACE_DEV_POLL_TOKEN::FIFO )

Initialize ACE_Dev_Poll_Reactor with size size. Note: On Unix platforms, the size parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons. If the size parameter is less than the process maximum, the process maximum will be decreased in order to prevent potential access violations. Definition at line 773 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_Timer_Queue, LM_ERROR, and open(). : initialized_ (false) , poll_fd_ (ACE_INVALID_HANDLE) , size_ (0) // , ready_set_ () #if defined (ACE_HAS_EVENT_POLL) , events_ (0) , start_pevents_ (0) , end_pevents_ (0) #else , dp_fds_ (0) , start_pfds_ (0) , end_pfds_ (0) #endif /* ACE_HAS_EVENT_POLL */ , deactivated_ (0) , token_ (*this, s_queue) , lock_adapter_ (token_) , timer_queue_ (0) , delete_timer_queue_ (0) , signal_handler_ (0) , delete_signal_handler_ (0) , notify_handler_ (0) , delete_notify_handler_ (0) , mask_signals_ (mask_signals) , restart_ (0) { if (this->open (size, rs, sh, tq, disable_notify_pipe, notify) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_Dev_Poll_Reactor::open ") ACE_LIB_TEXT ("failed inside ACE_Dev_Poll_Reactor::CTOR"))); }

ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor (  void   )  [virtual]

Close down and release all resources. Definition at line 818 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and close(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor"); (void) this->close (); }

---

Member Function Documentation

int ACE_Dev_Poll_Reactor::alertable_handle_events (  ACE_Time_Value &  max_wait_time  )  [virtual]

Implements ACE_Reactor_Impl. Definition at line 1473 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and handle_events(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::alertable_handle_events"); return this->handle_events (max_wait_time); }

int ACE_Dev_Poll_Reactor::alertable_handle_events (  ACE_Time_Value *  max_wait_time = 0  )  [virtual]

Implements ACE_Reactor_Impl. Definition at line 1457 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and handle_events(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::alertable_handle_events"); return this->handle_events (max_wait_time); }

int ACE_Dev_Poll_Reactor::cancel_timer (  long  timer_id, const void **  arg = 0, int  dont_call_handle_close = 1 )  [virtual]

Cancel the single event handler that matches the timer_id value (which was returned from the schedule method). If arg is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the event handler was registered. This makes it possible to free up the memory and avoid memory leaks. Returns 1 if cancellation succeeded and 0 if the timer_id wasn't found. Implements ACE_Reactor_Impl. Definition at line 2074 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::cancel(), and timer_queue_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_timer"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return (this->timer_queue_ == 0 ? 0 : this->timer_queue_->cancel (timer_id, arg, dont_call_handle_close)); }

int ACE_Dev_Poll_Reactor::cancel_timer (  ACE_Event_Handler *  event_handler, int  dont_call_handle_close = 1 )  [virtual]

Cancel all Event_Handlers that match the address of . Returns number of handlers cancelled. Implements ACE_Reactor_Impl. Definition at line 2060 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::cancel(), and timer_queue_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_timer"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return (this->timer_queue_ == 0 ? 0 : this->timer_queue_->cancel (event_handler, dont_call_handle_close)); }

int ACE_Dev_Poll_Reactor::cancel_wakeup (  ACE_HANDLE  handle, ACE_Reactor_Mask  masks_to_be_cleared )  [virtual]

Clear from the 's entry. Implements ACE_Reactor_Impl. Definition at line 2117 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, and mask_ops(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_wakeup"); return this->mask_ops (handle, mask, ACE_Reactor::CLR_MASK); }

int ACE_Dev_Poll_Reactor::cancel_wakeup (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  masks_to_be_cleared )  [virtual]

Clear from the 's entry. Implements ACE_Reactor_Impl. Definition at line 2108 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, ACE_Event_Handler::get_handle(), and mask_ops(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_wakeup"); return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::CLR_MASK); }

int ACE_Dev_Poll_Reactor::close (  void   )  [virtual]

Close down and release all resources. Implements ACE_Reactor_Impl. Definition at line 978 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Reactor_Notify::close(), ACE_Dev_Poll_Reactor_Handler_Repository::close(), ACE_OS::close(), delete_notify_handler_, delete_signal_handler_, delete_timer_queue_, end_pevents_, events_, handler_rep_, initialized_, notify_handler_, poll_fd_, signal_handler_, start_pevents_, and timer_queue_. Referenced by open(), and ~ACE_Dev_Poll_Reactor(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::close"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); int result = 0; if (this->poll_fd_ != ACE_INVALID_HANDLE) { result = ACE_OS::close (this->poll_fd_); } #if defined (ACE_HAS_EVENT_POLL) delete [] this->events_; this->events_ = 0; #else delete [] this->dp_fds_; this->dp_fds_ = 0; #endif /* ACE_HAS_EVENT_POLL */ if (this->delete_signal_handler_) { delete this->signal_handler_; this->signal_handler_ = 0; this->delete_signal_handler_ = 0; } (void) this->handler_rep_.close (); if (this->delete_timer_queue_) { delete this->timer_queue_; this->timer_queue_ = 0; this->delete_timer_queue_ = 0; } if (this->notify_handler_ != 0) this->notify_handler_->close (); if (this->delete_notify_handler_) { delete this->notify_handler_; this->notify_handler_ = 0; this->delete_notify_handler_ = 0; } this->poll_fd_ = ACE_INVALID_HANDLE; #if defined (ACE_HAS_EVENT_POLL) this->start_pevents_ = 0; this->end_pevents_ = 0; #else this->start_pfds_ = 0; this->end_pfds_ = 0; #endif /* ACE_HAS_EVENT_POLL */ this->initialized_ = false; return result; }

int ACE_Dev_Poll_Reactor::current_info (  ACE_HANDLE  handle, size_t &  )  [virtual]

Parameters: handle  allows the reactor to check if the caller is valid. Returns: 0 if the size of the current message has been put in size. -1 if not. Implements ACE_Reactor_Impl. Definition at line 940 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN. { ACE_NOTSUP_RETURN (-1); }

void ACE_Dev_Poll_Reactor::deactivate (  int  do_stop  )  [virtual]

Control whether the Reactor will handle any more incoming events or not. If do_stop == 1, the Reactor will be disabled. By default, a reactor is in active state and can be deactivated/reactived as desired. Implements ACE_Reactor_Impl. Definition at line 1487 of file Dev_Poll_Reactor.cpp. References deactivated_, and wakeup_all_threads(). { this->deactivated_ = do_stop; this->wakeup_all_threads (); }

int ACE_Dev_Poll_Reactor::deactivated (  void   )  [virtual]

Returns: The status of Reactor. If this function returns 0, the reactor is actively handling events. If it returns non-zero, handle_events() and handle_alertable_events() return -1 immediately. Implements ACE_Reactor_Impl. Definition at line 1481 of file Dev_Poll_Reactor.cpp. References deactivated_. { return this->deactivated_; }

int ACE_Dev_Poll_Reactor::dispatch (  Token_Guard &  guard  )  [protected]

Dispatch ACE_Event_Handlers for time events, I/O events, and signal events. Returns the total number of ACE_Event_Handlers that were dispatched or -1 if something goes wrong. Definition at line 1217 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, dispatch_io_event(), and dispatch_timer_handler(). Referenced by handle_events_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::dispatch"); // Perform the Template Method for dispatching the first located event. // We dispatch only one to effectively dispatch events concurrently. // As soon as an event is located, the token is released, allowing the // next waiter to begin getting an event while we dispatch one here. int result = 0; // Handle timers early since they may have higher latency // constraints than I/O handlers. Ideally, the order of // dispatching should be a strategy... if ((result = this->dispatch_timer_handler (guard)) != 0) return result; // Check to see if there are no more I/O handles left to // dispatch AFTER we've handled the timers. // Finally, dispatch the I/O handlers. result = this->dispatch_io_event (guard); return result; }

int ACE_Dev_Poll_Reactor::dispatch_io_event (  Token_Guard &  guard  )  [protected]

Dispatch an IO event to the corresponding event handler. Returns Returns: 0 if no events ready (token still held), 1 if an event was expired (token released), -1 on error (token still held). Definition at line 1306 of file Dev_Poll_Reactor.cpp. References ACE_BIT_ENABLED, ACE_CLR_BITS, ACE_ERROR, ACE_TEXT, end_pevents_, ACE_Dev_Poll_Reactor_Handler_Repository::find(), handler_rep_, LM_ERROR, ACE_Dev_Poll_Reactor::Token_Guard::release_token(), remove_handler(), remove_handler_i(), start_pevents_, and upcall(). Referenced by dispatch(). { // Define bits to check for while dispatching. #if defined (ACE_HAS_EVENT_POLL) const __uint32_t out_event = EPOLLOUT; const __uint32_t exc_event = EPOLLPRI; const __uint32_t in_event = EPOLLIN; const __uint32_t err_event = EPOLLHUP | EPOLLERR; #else const short out_event = POLLOUT; const short exc_event = POLLPRI; const short in_event = POLLIN; const short err_event = 0; // No known bits for this #endif /* ACE_HAS_EVENT_POLL */ // Since the underlying event demultiplexing mechansim (`/dev/poll' // or '/dev/epoll') is stateful, and since only one result buffer is // used, all pending events (i.e. those retrieved from a previous // poll) must be dispatched before any additional event can be // polled. As such, the Dev_Poll_Reactor keeps track of the // progress of events that have been dispatched. // Dispatch the events. // // Select the first available handle with event(s) pending. Check for // event type in defined order of dispatch: output, exception, input. // When an event is located, clear its bit in the dispatch set. If there // are no more events for the handle, also increment the pfds pointer // to move to the next handle ready. // // Notice that pfds only contains file descriptors that have // received events. #if defined (ACE_HAS_EVENT_POLL) struct epoll_event *& pfds = this->start_pevents_; if (pfds < this->end_pevents_) #else struct pollfd *& pfds = this->start_pfds_; if (pfds < this->end_pfds_) #endif /* ACE_HAS_EVENT_POLL */ { #if defined (ACE_HAS_EVENT_POLL) const ACE_HANDLE handle = pfds->data.fd; __uint32_t &revents = pfds->events; #else const ACE_HANDLE handle = pfds->fd; short &revents = pfds->revents; #endif /* ACE_HAS_EVENT_POLL */ // Figure out what to do first in order to make it easier to manage // the bit twiddling and possible pfds increment before releasing // the token for dispatch. // Note that if there's an error (such as the handle was closed // without being removed from the event set) the EPOLLHUP and/or // EPOLLERR bits will be set in revents. bool disp_out = false; bool disp_exc = false; bool disp_in = false; if (ACE_BIT_ENABLED (revents, out_event)) { disp_out = true; ACE_CLR_BITS (revents, out_event); } else if (ACE_BIT_ENABLED (revents, exc_event)) { disp_exc = true; ACE_CLR_BITS (revents, exc_event); } else if (ACE_BIT_ENABLED (revents, in_event)) { disp_in = true; ACE_CLR_BITS (revents, in_event); } else if (ACE_BIT_ENABLED (revents, err_event)) { this->remove_handler_i (handle, ACE_Event_Handler::ALL_EVENTS_MASK); ++pfds; return 1; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) dispatch_io h %d unknown events 0x%x\n"), handle, revents)); // ACE_ASSERT (0); } // Increment the pointer to the next element before we // release the token. Otherwise event handlers end up being // dispatched multiple times for the same poll. if (revents == 0) ++pfds; /* When using sys_epoll, we can attach arbitrary user data to the descriptor, so it can be delivered when activity is detected. Perhaps we should store event handler together with descriptor, instead of looking it up in a repository ? Could it boost performance ? */ ACE_Event_Handler *eh = this->handler_rep_.find (handle); if (eh) { // Modify the reference count in an exception-safe way. // Note that eh could be the notify handler. It's not strictly // necessary to manage its refcount, but since we don't enable // the counting policy, it won't do much. Management of the // notified handlers themselves is done in the notify handler. ACE_Dev_Poll_Handler_Guard eh_guard (eh); // Release the reactor token before upcall. guard.release_token (); // Dispatch the detected event if (disp_out) { const int status = this->upcall (eh, &ACE_Event_Handler::handle_output, handle); if (status < 0) // Note that the token is reacquired in remove_handler(). this->remove_handler (handle, ACE_Event_Handler::WRITE_MASK); return 1; } if (disp_exc) { const int status = this->upcall (eh, &ACE_Event_Handler::handle_exception, handle); if (status < 0) // Note that the token is reacquired in remove_handler(). this->remove_handler (handle, ACE_Event_Handler::EXCEPT_MASK); return 1; } if (disp_in) { const int status = this->upcall (eh, &ACE_Event_Handler::handle_input, handle); if (status < 0) // Note that the token is reacquired in remove_handler(). this->remove_handler (handle, ACE_Event_Handler::READ_MASK); return 1; } } // The reactor token is reacquired upon leaving this scope. } return 0; }

int ACE_Dev_Poll_Reactor::dispatch_timer_handler (  Token_Guard &  guard  )  [protected]

Dispatch a single timer, if ready. Returns: 0 if no timers ready (token still held), 1 if a timer was expired (token released), -1 on error (token still held). Definition at line 1243 of file Dev_Poll_Reactor.cpp. References ACE_Timer_Node_Dispatch_Info, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::postinvoke(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::preinvoke(), ACE_Dev_Poll_Reactor::Token_Guard::release_token(), timer_queue_, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall(). Referenced by dispatch(). { if (this->timer_queue_->is_empty()) return 0; // Empty timer queue so cannot have any expired timers. // Get the current time ACE_Time_Value cur_time (this->timer_queue_->gettimeofday () + this->timer_queue_->timer_skew ()); // Look for a node in the timer queue whose timer <= the present // time. ACE_Timer_Node_Dispatch_Info info; if (this->timer_queue_->dispatch_info (cur_time, info)) { const void *upcall_act = 0; // Preinvoke (handles refcount if needed, etc.) this->timer_queue_->preinvoke (info, cur_time, upcall_act); // Release the token before expiration upcall. guard.release_token (); // call the functor this->timer_queue_->upcall (info, cur_time); // Postinvoke (undo refcount if needed, etc.) this->timer_queue_->postinvoke (info, cur_time, upcall_act); // We have dispatched a timer return 1; } return 0; }

void ACE_Dev_Poll_Reactor::dump (  void   )  const [virtual]

Dump the state of an object. Implements ACE_Reactor_Impl. Definition at line 2498 of file Dev_Poll_Reactor.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, and LM_DEBUG. { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Dev_Poll_Reactor::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("restart_ = %d\n"), this->restart_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("initialized_ = %d"), this->initialized_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("poll_fd_ = %d"), this->poll_fd_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("size_ = %u"), this->size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("deactivated_ = %d"), this->deactivated_)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

ACE_Event_Handler * ACE_Dev_Poll_Reactor::find_handler (  ACE_HANDLE  handle  )  [virtual]

Return the Event_Handler associated with . Return 0 if is not registered. Implements ACE_Reactor_Impl. Definition at line 2174 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_READ_GUARD_RETURN, ACE_Event_Handler::add_reference(), ACE_Dev_Poll_Reactor_Handler_Repository::find(), and handler_rep_. { ACE_MT (ACE_READ_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, 0)); ACE_Event_Handler *event_handler = this->handler_rep_.find (handle); if (event_handler) event_handler->add_reference (); return event_handler; }

int ACE_Dev_Poll_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. Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl. Definition at line 1465 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and handle_events(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events"); return this->handle_events (&max_wait_time); }

int ACE_Dev_Poll_Reactor::handle_events (  ACE_Time_Value *  max_wait_time = 0  )  [virtual]

This event loop driver blocks for up to max_wait_time before returning. It will return earlier if 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. The only difference between alertable_handle_events() and handle_events() is that in the alertable case, the event loop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call. 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 an error occurs. Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl. Definition at line 1143 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Dev_Poll_Reactor::Token_Guard::acquire_quietly(), deactivated_, handle_events_i(), and ACE_Dev_Poll_Reactor::Token_Guard::is_owner(). Referenced by alertable_handle_events(), and handle_events(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events"); // Stash the current time // // The destructor of this object will automatically compute how much // time elapsed since this method was called. ACE_MT (ACE_Countdown_Time countdown (max_wait_time)); Token_Guard guard (this->token_); int result = guard.acquire_quietly (max_wait_time); // If the guard is NOT the owner just return the retval if (!guard.is_owner ()) return result; if (this->deactivated_) return -1; // Update the countdown to reflect time waiting for the mutex. ACE_MT (countdown.update ()); return this->handle_events_i (max_wait_time, guard); }

int ACE_Dev_Poll_Reactor::handle_events_i (  ACE_Time_Value *  max_wait_time, Token_Guard &  guard )  [protected]

This is a helper method called by all handle_events() methods. Definition at line 1170 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_TRACE, dispatch(), ETIME, LM_ERROR, ACE_Sig_Handler::sig_pending(), and work_pending_i(). Referenced by handle_events(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events_i"); int result = 0; // int active_handle_count = 0; // Poll for events // // If the underlying ioctl() call was interrupted via the interrupt // signal (i.e. returned -1 with errno == EINTR) then the loop will // be restarted if so desired. do { result = this->work_pending_i (max_wait_time); if (result == -1) ACE_ERROR((LM_ERROR, "%t: %p\n", "work_pending_i")); } while (result == -1 && this->restart_ != 0 && errno == EINTR); if (result == 0 || (result == -1 && errno == ETIME)) return 0; else if (result == -1) { if (errno != EINTR) return -1; // Bail out -- we got here since the poll was interrupted. // If it was due to a signal registered through our ACE_Sig_Handler, // then it was dispatched, so we count it in the number of events // handled rather than cause an error return. if (ACE_Sig_Handler::sig_pending () != 0) { ACE_Sig_Handler::sig_pending (0); return 1; } return -1; } // Dispatch an event. return this->dispatch (guard); }

int ACE_Dev_Poll_Reactor::handler (  int  signum, ACE_Event_Handler **  = 0 )  [virtual]

Check to see if is associated with a valid Event_Handler bound to a signal. Return the associated with this if != 0. Implements ACE_Reactor_Impl. Definition at line 2210 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Sig_Handler::handler(), and signal_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::handler"); ACE_Event_Handler *handler = this->signal_handler_->handler (signum); if (handler == 0) return -1; else if (eh != 0) *eh = handler; return 0; }

int ACE_Dev_Poll_Reactor::handler (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask, ACE_Event_Handler **  event_handler = 0 )  [virtual]

Check to see if is associated with a valid Event_Handler bound to . Return the associated with this if != 0. Implements ACE_Reactor_Impl. Definition at line 2185 of file Dev_Poll_Reactor.cpp. References ACE_BIT_CMP_MASK, ACE_Dev_Poll_Reactor_Token, ACE_Reactor_Mask, ACE_READ_GUARD_RETURN, ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::find(), and handler_rep_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::handler"); ACE_MT (ACE_READ_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); ACE_Event_Handler *h = this->handler_rep_.find (handle); if (h != 0 && ACE_BIT_CMP_MASK (this->handler_rep_.mask (handle), mask, // Compare all bits in the mask mask)) { if (event_handler != 0) *event_handler = h; return 0; } return -1; }

int ACE_Dev_Poll_Reactor::initialized (  void   )  [virtual]

Returns true if Reactor has been successfully initialized, else false. Implements ACE_Reactor_Impl. Definition at line 2226 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, and initialized_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::initialized"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->initialized_; }

ACE_Lock & ACE_Dev_Poll_Reactor::lock (  void   )  [virtual]

Returns a reference to the Reactor's internal lock. Implements ACE_Reactor_Impl. Definition at line 2242 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and lock_adapter_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::lock"); return this->lock_adapter_; }

int ACE_Dev_Poll_Reactor::mask_ops (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask, int  ops )  [virtual]

Returns: Old mask on success, -1 on error. Implements ACE_Reactor_Impl. Definition at line 2333 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, and mask_ops_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->mask_ops_i (handle, mask, ops); }

int ACE_Dev_Poll_Reactor::mask_ops (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask, int  ops )  [virtual]

Returns: Old mask on success, -1 on error. Implements ACE_Reactor_Impl. Definition at line 2321 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, ACE_Event_Handler::get_handle(), and mask_ops_i(). Referenced by cancel_wakeup(), and schedule_wakeup(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->mask_ops_i (event_handler->get_handle (), mask, ops); }

int ACE_Dev_Poll_Reactor::mask_ops_i (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask, int  ops )  [protected]

Returns: Old mask on success, -1 on error. Definition at line 2345 of file Dev_Poll_Reactor.cpp. References ACE_CLR_BITS, ACE_Reactor_Mask, ACE_SET_BITS, ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::handle_in_range(), handler_rep_, ACE_Dev_Poll_Reactor_Handler_Repository::mask(), ACE_OS::memset(), poll_fd_, reactor_mask_to_poll_event(), ACE_Dev_Poll_Reactor_Handler_Repository::suspended(), and ACE_OS::write(). Referenced by mask_ops(), register_handler_i(), and remove_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops_i"); if (this->handler_rep_.handle_in_range (handle) == 0) return -1; // Block out all signals until method returns. ACE_Sig_Guard sb; const ACE_Reactor_Mask old_mask = this->handler_rep_.mask (handle); ACE_Reactor_Mask new_mask = old_mask; // Perform GET, CLR, SET, and ADD operations on the interest/wait // set and the suspend set (if necessary). // // GET = 1, Retrieve current value // SET = 2, Set value of bits to new mask (changes the entire mask) // ADD = 3, Bitwise "or" the value into the mask (only changes // enabled bits) // CLR = 4 Bitwise "and" the negation of the value out of the mask // (only changes enabled bits) // // Returns the original mask. switch (ops) { case ACE_Reactor::GET_MASK: // The work for this operation is done in all cases at the // begining of the function. return old_mask; case ACE_Reactor::CLR_MASK: ACE_CLR_BITS (new_mask, mask); break; case ACE_Reactor::SET_MASK: new_mask = mask; break; case ACE_Reactor::ADD_MASK: ACE_SET_BITS (new_mask, mask); break; default: return -1; } /// Reset the mask for the given handle. this->handler_rep_.mask (handle, new_mask); if (this->handler_rep_.suspended (handle) == 0) { // Only attempt to alter events for the handle from the // "interest set" if it hasn't been suspended. const short events = this->reactor_mask_to_poll_event (new_mask); #if defined (sun) // Apparently events cannot be updated on-the-fly on Solaris so // remove the existing events, and then add the new ones. struct pollfd pfd[2]; pfd[0].fd = handle; pfd[0].events = POLLREMOVE; pfd[0].revents = 0; pfd[1].fd = (events == POLLREMOVE ? ACE_INVALID_HANDLE : handle); pfd[1].events = events; pfd[1].revents = 0; // Change the events associated with the given file descriptor. if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) return -1; #elif defined (ACE_HAS_EVENT_POLL) struct epoll_event epev; ACE_OS::memset (&epev, 0, sizeof (epev)); int op; // ACE_Event_Handler::NULL_MASK ??? if (new_mask == 0) { op = EPOLL_CTL_DEL; epev.events = 0; } else { op = EPOLL_CTL_MOD; epev.events = events; } epev.data.fd = handle; if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) { // If a handle is closed, epoll removes it from the poll set // automatically - we may not know about it yet. If that's the // case, a mod operation will fail with ENOENT. Retry it as // an add. if (op == EPOLL_CTL_MOD && errno == ENOENT && ::epoll_ctl (this->poll_fd_, EPOLL_CTL_ADD, handle, &epev) == -1) return -1; } #else pollfd pfd[1]; pfd[0].fd = handle; pfd[0].events = events; pfd[0].revents = 0; // Change the events associated with the given file descriptor. if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) return -1; #endif /*ACE_HAS_EVENT_POLL */ } return old_mask; }

int ACE_Dev_Poll_Reactor::max_notify_iterations (  void   )  [virtual]

Get the maximum number of times that the ACE_Reactor_Impl will iterate and dispatch the that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. Implements ACE_Reactor_Impl. Definition at line 2154 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Reactor_Notify::max_notify_iterations(), and notify_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::max_notify_iterations"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->notify_handler_->max_notify_iterations (); }

void ACE_Dev_Poll_Reactor::max_notify_iterations (  int   )  [virtual]

Set the maximum number of times that ACE_Reactor_Impl will iterate and dispatch the that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. By default, this is set to -1, which means "iterate until the queue is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead. Implements ACE_Reactor_Impl. Definition at line 2144 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD, ACE_TRACE, ACE_Reactor_Notify::max_notify_iterations(), and notify_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::max_notify_iterations"); ACE_MT (ACE_GUARD (ACE_Dev_Poll_Reactor_Token, mon, this->token_)); this->notify_handler_->max_notify_iterations (iterations); }

int ACE_Dev_Poll_Reactor::notify (  ACE_Event_Handler *  event_handler = 0, ACE_Reactor_Mask  mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *  = 0 )  [virtual]

Notify of event. The indicates how long to blocking trying to notify. If == 0, the caller will block until action is possible, else will wait until the relative time specified in elapses). Implements ACE_Reactor_Impl. Definition at line 2126 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, ACE_Reactor_Notify::notify(), notify_handler_, and ssize_t. Referenced by wakeup_all_threads(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::notify"); ssize_t n = 0; // Pass over both the Event_Handler *and* the mask to allow the // caller to dictate which Event_Handler method the receiver // invokes. Note that this call can timeout. n = this->notify_handler_->notify (eh, mask, timeout); return n == -1 ? -1 : 0; }

int ACE_Dev_Poll_Reactor::open (  size_t  size, int  restart = 0, ACE_Sig_Handler *  = 0, ACE_Timer_Queue *  = 0, int  disable_notify_pipe = 0, ACE_Reactor_Notify *  = 0 )  [virtual]

Initialization. Implements ACE_Reactor_Impl. Definition at line 826 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_Timer_Heap, ACE_Timer_Queue, ACE_TRACE, close(), delete_notify_handler_, delete_signal_handler_, delete_timer_queue_, handler_rep_, initialized_, notify_handler_, ACE_Reactor_Notify::open(), ACE_Dev_Poll_Reactor_Handler_Repository::open(), ACE_OS::open(), poll_fd_, register_handler_i(), signal_handler_, and timer_queue_. Referenced by ACE_Dev_Poll_Reactor(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::open"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); // Can't initialize ourselves more than once. if (this->initialized_) return -1; this->restart_ = restart; this->signal_handler_ = sh; this->timer_queue_ = tq; this->notify_handler_ = notify; int result = 0; // Allows the signal handler to be overridden. if (this->signal_handler_ == 0) { ACE_NEW_RETURN (this->signal_handler_, ACE_Sig_Handler, -1); if (this->signal_handler_ == 0) result = -1; else this->delete_signal_handler_ = 1; } // Allows the timer queue to be overridden. if (result != -1 && this->timer_queue_ == 0) { ACE_NEW_RETURN (this->timer_queue_, ACE_Timer_Heap, -1); if (this->timer_queue_ == 0) result = -1; else this->delete_timer_queue_ = 1; } // Allows the Notify_Handler to be overridden. if (result != -1 && this->notify_handler_ == 0) { ACE_NEW_RETURN (this->notify_handler_, ACE_Dev_Poll_Reactor_Notify, -1); if (this->notify_handler_ == 0) result = -1; else this->delete_notify_handler_ = 1; } #if defined (ACE_HAS_EVENT_POLL) // Allocating event table: ACE_NEW_RETURN (this->events_, epoll_event[size], -1); // Initializing epoll: this->poll_fd_ = ::epoll_create (size); if (this->poll_fd_ == -1) result = -1; #else // Allocate the array before opening the device to avoid a potential // resource leak if allocation fails. ACE_NEW_RETURN (this->dp_fds_, pollfd[size], -1); // Open the `/dev/poll' character device. this->poll_fd_ = ACE_OS::open ("/dev/poll", O_RDWR); if (this->poll_fd_ == ACE_INVALID_HANDLE) result = -1; #endif /* ACE_HAS_EVENT_POLL */ if (result != -1 && this->handler_rep_.open (size) == -1) result = -1; // Registration of the notification handler must be done after the // /dev/poll device has been fully initialized. else if (this->notify_handler_->open (this, 0, disable_notify_pipe) == -1 || (disable_notify_pipe == 0 && this->register_handler_i ( this->notify_handler_->notify_handle (), this->notify_handler_, ACE_Event_Handler::READ_MASK)) == -1) result = -1; this->size_ = size; if (result != -1) // We're all set to go. this->initialized_ = true; else // This will close down all the allocated resources properly. (void) this->close (); return result; }

int ACE_Dev_Poll_Reactor::owner (  ACE_thread_t *  owner  )  [virtual]

Return the ID of the "owner" thread. Note: There is no need to set the owner of the event loop for the ACE_Dev_Poll_Reactor. Multiple threads may invoke the event loop simulataneously. As such, this method is a no-op. Implements ACE_Reactor_Impl. Definition at line 2274 of file Dev_Poll_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::owner"); // There is no need to set the owner of the event loop. Multiple // threads may invoke the event loop simulataneously. return 0; }

int ACE_Dev_Poll_Reactor::owner (  ACE_thread_t  new_owner, ACE_thread_t *  old_owner = 0 )  [virtual]

Transfers ownership of Reactor_Impl to the new_owner. Note: There is no need to set the owner of the event loop for the ACE_Dev_Poll_Reactor. Multiple threads may invoke the event loop simulataneously. As such, this method is a no-op. Implements ACE_Reactor_Impl. Definition at line 2262 of file Dev_Poll_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::owner"); // There is no need to set the owner of the event loop. Multiple // threads may invoke the event loop simulataneously. return 0; }

int ACE_Dev_Poll_Reactor::purge_pending_notifications (  ACE_Event_Handler *  = 0, ACE_Reactor_Mask  = ACE_Event_Handler::ALL_EVENTS_MASK )  [virtual]

Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. Returns the number of notifications purged. Returns -1 on error. Implements ACE_Reactor_Impl. Definition at line 2164 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, notify_handler_, and ACE_Reactor_Notify::purge_pending_notifications(). { if (this->notify_handler_ == 0) return 0; return this->notify_handler_->purge_pending_notifications (eh, mask); }

short ACE_Dev_Poll_Reactor::reactor_mask_to_poll_event (  ACE_Reactor_Mask  mask  )  [protected]

Convert a reactor mask to its corresponding poll() event mask. Definition at line 2518 of file Dev_Poll_Reactor.cpp. References ACE_BIT_ENABLED, ACE_Reactor_Mask, ACE_SET_BITS, and ACE_TRACE. Referenced by mask_ops_i(), register_handler_i(), and resume_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::reactor_mask_to_poll_event"); if (mask == ACE_Event_Handler::NULL_MASK) // No event. Remove from interest set. #if defined (ACE_HAS_EVENT_POLL) return EPOLL_CTL_DEL; #else return POLLREMOVE; #endif /* ACE_HAS_EVENT_POLL */ short events = 0; // READ, ACCEPT, and CONNECT flag will place the handle in the // read set. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) { #if defined (ACE_HAS_EVENT_POLL) ACE_SET_BITS (events, EPOLLIN); #else ACE_SET_BITS (events, POLLIN); #endif /*ACE_HAS_EVENT_POLL*/ } // WRITE and CONNECT flag will place the handle in the write set. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) { #if defined (ACE_HAS_EVENT_POLL) ACE_SET_BITS (events, EPOLLOUT); #else ACE_SET_BITS (events, POLLOUT); #endif /*ACE_HAS_EVENT_POLL*/ } // EXCEPT flag will place the handle in the except set. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) { #if defined (ACE_HAS_EVENT_POLL) ACE_SET_BITS (events, EPOLLPRI); #else ACE_SET_BITS (events, POLLPRI); #endif /*ACE_HAS_EVENT_POLL*/ } return events; }

int ACE_Dev_Poll_Reactor::ready_ops (  ACE_HANDLE  handle, ACE_Reactor_Mask  , int  ops )  [virtual]

GET/SET/ADD/CLR the ready "bit" bound with the handle and mask. Implements ACE_Reactor_Impl. Definition at line 2485 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, ACE_Reactor_Mask, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::ready_ops"); // Since the Dev_Poll_Reactor uses the poll result buffer, the // ready_set cannot be directly manipulated outside of the event // loop. ACE_NOTSUP_RETURN (-1); }

int ACE_Dev_Poll_Reactor::ready_ops (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask, int  ops )  [virtual]

GET/SET/ADD/CLR the ready "bit" bound with the event_handler and mask. Implements ACE_Reactor_Impl. Definition at line 2472 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, ACE_Reactor_Mask, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::ready_ops"); // Since the Dev_Poll_Reactor uses the poll result buffer, the // ready_set cannot be directly manipulated outside of the event // loop. ACE_NOTSUP_RETURN (-1); }

int ACE_Dev_Poll_Reactor::register_handler (  const ACE_Sig_Set &  sigset, ACE_Event_Handler *  new_sh, ACE_Sig_Action *  new_disp = 0 )  [virtual]

Registers to handle a set of signals using the . Implements ACE_Reactor_Impl. Definition at line 1643 of file Dev_Poll_Reactor.cpp. References ACE_NSIG, ACE_TRACE, ACE_Sig_Set::is_member(), ACE_Sig_Handler::register_handler(), and signal_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); int result = 0; #if (ACE_NSIG > 0) for (int s = 1; s < ACE_NSIG; ++s) if ((sigset.is_member (s) == 1) && this->signal_handler_->register_handler (s, new_sh, new_disp) == -1) result = -1; #else /* ACE_NSIG <= 0 */ ACE_UNUSED_ARG (sigset); ACE_UNUSED_ARG (new_sh); ACE_UNUSED_ARG (new_disp); #endif /* ACE_NSIG <= 0 */ return result; }

int ACE_Dev_Poll_Reactor::register_handler (  int  signum, ACE_Event_Handler *  new_sh, ACE_Sig_Action *  new_disp = 0, ACE_Event_Handler **  old_sh = 0, ACE_Sig_Action *  old_disp = 0 )  [virtual]

Register new_sh to handle the signal signum using the new_disp. Returns the old_sh that was previously registered (if any), along with the old_disp of the signal handler. Implements ACE_Reactor_Impl. Definition at line 1627 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Sig_Handler::register_handler(), and signal_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); return this->signal_handler_->register_handler (signum, new_sh, new_disp, old_sh, old_disp); }

int ACE_Dev_Poll_Reactor::register_handler (  const ACE_Handle_Set &  handles, ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask )  [virtual]

Register event_handler> with all the handles> in the Handle_Set. Implements ACE_Reactor_Impl. Definition at line 1602 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, and register_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); ACE_Handle_Set_Iterator handle_iter (handle_set); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); // @@ It might be more efficient to construct a pollfd array and // pass it to the write() call in register_handler_i() only once, // instead of calling write() (a system call) once for each file // descriptor. for (ACE_HANDLE h = handle_iter (); h != ACE_INVALID_HANDLE; h = handle_iter ()) if (this->register_handler_i (h, event_handler, mask) == -1) return -1; return 0; }

int ACE_Dev_Poll_Reactor::register_handler (  ACE_HANDLE  event_handle, ACE_HANDLE  io_handle, ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask )  [virtual]

Register an event_handler that will be notified when event_handle is signaled. mask specifies the network events that the event_handler is interested in. Implements ACE_Reactor_Impl. Definition at line 1592 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, and ACE_Reactor_Mask. { ACE_NOTSUP_RETURN (-1); }

int ACE_Dev_Poll_Reactor::register_handler (  ACE_HANDLE  io_handle, ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask )  [virtual]

Register event_handler with mask. The I/O handle is provided through the io_handle parameter. Implements ACE_Reactor_Impl. Definition at line 1507 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, and register_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->register_handler_i (handle, event_handler, mask); }

int ACE_Dev_Poll_Reactor::register_handler (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask )  [virtual]

Register event_handler with mask. The I/O handle will always come from get_handle on the event_handler. Implements ACE_Reactor_Impl. Definition at line 1494 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, ACE_Event_Handler::get_handle(), and register_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->register_handler_i (handler->get_handle (), handler, mask); }

int ACE_Dev_Poll_Reactor::register_handler_i (  ACE_HANDLE  handle, ACE_Event_Handler *  eh, ACE_Reactor_Mask  mask )  [protected]

Register the given event handler with the reactor. Definition at line 1521 of file Dev_Poll_Reactor.cpp. References ACE_ERROR, ACE_ERROR_RETURN, ACE_Reactor_Mask, ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::bind(), ACE_Dev_Poll_Reactor_Handler_Repository::find(), handler_rep_, LM_ERROR, mask_ops_i(), ACE_OS::memset(), poll_fd_, reactor_mask_to_poll_event(), ACE_Dev_Poll_Reactor_Handler_Repository::unbind(), and ACE_OS::write(). Referenced by open(), and register_handler(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler_i"); if (handle == ACE_INVALID_HANDLE || mask == ACE_Event_Handler::NULL_MASK) { errno = EINVAL; return -1; } if (this->handler_rep_.find (handle) == 0) { // Handler not present in the repository. Bind it. if (this->handler_rep_.bind (handle, event_handler, mask) != 0) return -1; #if defined (ACE_HAS_EVENT_POLL) struct epoll_event epev; ACE_OS::memset (&epev, 0, sizeof (epev)); static const int op = EPOLL_CTL_ADD; epev.events = this->reactor_mask_to_poll_event (mask); epev.data.fd = handle; if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "epoll_ctl")); (void) this->handler_rep_.unbind (handle); return -1; } #endif /* ACE_HAS_EVENT_POLL */ } else { // Handler is already present in the repository, so register it // again, possibly for different event. Add new mask to the // current one. if (this->mask_ops_i (handle, mask, ACE_Reactor::ADD_MASK) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "mask_ops_i"), -1); } #ifndef ACE_HAS_EVENT_POLL struct pollfd pfd; pfd.fd = handle; pfd.events = this->reactor_mask_to_poll_event (mask); pfd.revents = 0; // Add file descriptor to the "interest set." if (ACE_OS::write (this->poll_fd_, &pfd, sizeof (pfd)) != sizeof (pfd)) { (void) this->handler_rep_.unbind (handle); return -1; } #endif /*ACE_HAS_EVENT_POLL*/ // Note the fact that we've changed the state of the wait_set_, // which is used by the dispatching loop to determine whether it can // keep going or if it needs to reconsult select(). // this->state_changed_ = 1; return 0; }

int ACE_Dev_Poll_Reactor::remove_handler (  const ACE_Sig_Set &  sigset  )  [virtual]

Calls for every signal in . Implements ACE_Reactor_Impl. Definition at line 1766 of file Dev_Poll_Reactor.cpp. References ACE_NSIG, ACE_TRACE, ACE_Sig_Set::is_member(), ACE_Sig_Handler::remove_handler(), and signal_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); int result = 0; #if (ACE_NSIG > 0) for (int s = 1; s < ACE_NSIG; ++s) if ((sigset.is_member (s) == 1) && this->signal_handler_->remove_handler (s) == -1) result = -1; #else /* ACE_NSIG <= 0 */ ACE_UNUSED_ARG (sigset); #endif /* ACE_NSIG <= 0 */ return result; }

int ACE_Dev_Poll_Reactor::remove_handler (  int  signum, ACE_Sig_Action *  new_disp, ACE_Sig_Action *  old_disp = 0, int  sigkey = -1 )  [virtual]

Remove the ACE_Event_Handler currently associated with . Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if is invalid. Implements ACE_Reactor_Impl. Definition at line 1752 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Sig_Handler::remove_handler(), and signal_handler_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); return this->signal_handler_->remove_handler (signum, new_disp, old_disp, sigkey); }

int ACE_Dev_Poll_Reactor::remove_handler (  const ACE_Handle_Set &  handle_set, ACE_Reactor_Mask  mask )  [virtual]

Removes all handles in . If == <ACE_Event_Handler::DONT_CALL> then the method of the associated s is not invoked. Implements ACE_Reactor_Impl. Definition at line 1728 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, and remove_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); ACE_Handle_Set_Iterator handle_iter (handle_set); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); // @@ It might be more efficient to construct a pollfd array and // pass it to the write() call in register_handler_i() only once, // instead of calling write() (a system call) once for each file // descriptor. for (ACE_HANDLE h = handle_iter (); h != ACE_INVALID_HANDLE; h = handle_iter ()) if (this->remove_handler_i (h, mask) == -1) return -1; return 0; }

int ACE_Dev_Poll_Reactor::remove_handler (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask )  [virtual]

Removes . If == <ACE_Event_Handler::DONT_CALL> then the method of the associated is not invoked. Implements ACE_Reactor_Impl. Definition at line 1683 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, and remove_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->remove_handler_i (handle, mask); }

int ACE_Dev_Poll_Reactor::remove_handler (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  mask )  [virtual]

Removes event_handler. Note: The I/O handle will be obtained using get_handle() method of event_handler . If mask == ACE_Event_Handler::DONT_CALL then the handle_close() method of the event_handler is not invoked. Implements ACE_Reactor_Impl. Definition at line 1672 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_TRACE, ACE_Event_Handler::get_handle(), and remove_handler_i(). Referenced by dispatch_io_event(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->remove_handler_i (handler->get_handle (), mask); }

int ACE_Dev_Poll_Reactor::remove_handler_i (  ACE_HANDLE  handle, ACE_Reactor_Mask  mask )  [protected]

Remove the event handler associated with the given handle and event mask from the "interest set." Definition at line 1694 of file Dev_Poll_Reactor.cpp. References ACE_BIT_DISABLED, ACE_Reactor_Mask, ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::find(), ACE_Event_Handler::handle_close(), handler_rep_, ACE_Dev_Poll_Reactor_Handler_Repository::mask(), mask_ops_i(), ACE_Event_Handler::reference_counting_policy(), and ACE_Dev_Poll_Reactor_Handler_Repository::unbind(). Referenced by dispatch_io_event(), and remove_handler(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler_i"); ACE_Event_Handler *eh = this->handler_rep_.find (handle); if (eh == 0 || this->mask_ops_i (handle, mask, ACE_Reactor::CLR_MASK) == -1) return -1; // Check for ref counting now - handle_close() may delete eh. int requires_reference_counting = eh->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; if (ACE_BIT_DISABLED (mask, ACE_Event_Handler::DONT_CALL)) (void) eh->handle_close (handle, mask); // If there are no longer any outstanding events on the given handle // then remove it from the handler repository. if (this->handler_rep_.mask (handle) == ACE_Event_Handler::NULL_MASK) this->handler_rep_.unbind (handle, requires_reference_counting); // Note the fact that we've changed the state of the wait_set, // i.e. the "interest set," which is used by the dispatching loop to // determine whether it can keep going or if it needs to reconsult // /dev/poll or /dev/epoll. // this->state_changed_ = 1; return 0; }

int ACE_Dev_Poll_Reactor::requeue_position (  void   )  [virtual]

Get position of the owner thread. Note: This is currently a no-op. Implements ACE_Reactor_Impl. Definition at line 2313 of file Dev_Poll_Reactor.cpp. References ACE_NOTSUP_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::requeue_position"); ACE_NOTSUP_RETURN (-1); }

void ACE_Dev_Poll_Reactor::requeue_position (  int   )  [virtual]

Set position of the owner thread. Note: This is currently a no-op. Implements ACE_Reactor_Impl. Definition at line 2307 of file Dev_Poll_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::requeue_position"); }

int ACE_Dev_Poll_Reactor::reset_timer_interval (  long  timer_id, const ACE_Time_Value &  interval )  [virtual]

Resets the interval of the timer represented by to , which is specified in relative time to the current . If is equal to <ACE_Time_Value::zero>, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not. Implements ACE_Reactor_Impl. Definition at line 2045 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ESHUTDOWN, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::reset_interval(), and timer_queue_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::reset_timer_interval"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); if (0 != this->timer_queue_) return this->timer_queue_->reset_interval (timer_id, interval); errno = ESHUTDOWN; return -1; }

int ACE_Dev_Poll_Reactor::restart (  int  r  )  [virtual]

Set a new value for restart and return the original value. Parameters: r  If zero, then the event loop will not be automatically restarted if the underlying poll is interrupted via the INTR (interrupt) signal. Returns: Returns the previous "restart" value. Implements ACE_Reactor_Impl. Definition at line 2295 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::restart"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); int current_value = this->restart_; this->restart_ = r; return current_value; }

int ACE_Dev_Poll_Reactor::restart (  void   )  [virtual]

Get the existing restart value. Implements ACE_Reactor_Impl. Definition at line 2285 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor::restart"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->restart_; }

int ACE_Dev_Poll_Reactor::resumable_handler (  void   )  [virtual]

Does the reactor allow the application to resume the handle on its own, i.e., can it pass on the control of handle resumption to the application. Implements ACE_Reactor_Impl. Definition at line 2008 of file Dev_Poll_Reactor.cpp. { // @@ Is this correct? return 0; }

int ACE_Dev_Poll_Reactor::resume_handler (  const ACE_Handle_Set &  handles  )  [virtual]

Resume all handles in handle set. Implements ACE_Reactor_Impl. Definition at line 1926 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, and resume_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); ACE_Handle_Set_Iterator handle_iter (handles); ACE_HANDLE h; ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); while ((h = handle_iter ()) != ACE_INVALID_HANDLE) if (this->resume_handler_i (h) == -1) return -1; return 0; }

int ACE_Dev_Poll_Reactor::resume_handler (  ACE_HANDLE  handle  )  [virtual]

Resume handle. Implements ACE_Reactor_Impl. Definition at line 1916 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, and resume_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->resume_handler_i (handle); }

int ACE_Dev_Poll_Reactor::resume_handler (  ACE_Event_Handler *  event_handler  )  [virtual]

Resume event_handler. Use ACE_Event_Handler::get_handle() to get the handle. Implements ACE_Reactor_Impl. Definition at line 1898 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Event_Handler::get_handle(), and resume_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); if (event_handler == 0) { errno = EINVAL; return -1; } ACE_HANDLE handle = event_handler->get_handle (); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->resume_handler_i (handle); }

int ACE_Dev_Poll_Reactor::resume_handler_i (  ACE_HANDLE  handle  )  [protected]

Place the given handle that was temporarily removed from the "interest set," i.e that was suspended, back in to the interest set. The given handle will once again be polled for events. Definition at line 1960 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::find(), handler_rep_, ACE_Dev_Poll_Reactor_Handler_Repository::mask(), ACE_OS::memset(), poll_fd_, reactor_mask_to_poll_event(), ACE_Dev_Poll_Reactor_Handler_Repository::resume(), ACE_Dev_Poll_Reactor_Handler_Repository::suspended(), and ACE_OS::write(). Referenced by resume_handler(), and resume_handlers(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler_i"); if (this->handler_rep_.find (handle) == 0 && this->handler_rep_.suspended (handle) == 0) return -1; ACE_Reactor_Mask mask = this->handler_rep_.mask (handle); if (mask == ACE_Event_Handler::NULL_MASK) return -1; // Place the handle back in to the "interest set." // // Events for the given handle will once again be polled. #if defined (ACE_HAS_EVENT_POLL) struct epoll_event epev; ACE_OS::memset (&epev, 0, sizeof (epev)); static const int op = EPOLL_CTL_ADD; epev.events = this->reactor_mask_to_poll_event (mask); epev.data.fd = handle; if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) return -1; #else struct pollfd pfd[1]; pfd[0].fd = handle; pfd[0].events = this->reactor_mask_to_poll_event (mask); pfd[0].revents = 0; if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) return -1; #endif /* ACE_HAS_EVENT_POLL */ this->handler_rep_.resume (handle); return 0; }

int ACE_Dev_Poll_Reactor::resume_handlers (  void   )  [virtual]

Resume all handles. Implements ACE_Reactor_Impl. Definition at line 1943 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, handler_rep_, resume_handler_i(), ACE_Dev_Poll_Reactor_Handler_Repository::size(), and ACE_Dev_Poll_Reactor_Handler_Repository::suspended(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handlers"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); const size_t len = this->handler_rep_.size (); for (size_t i = 0; i < len; ++i) if (this->handler_rep_.suspended (i) && this->resume_handler_i (i) != 0) return -1; return 0; }

long ACE_Dev_Poll_Reactor::schedule_timer (  ACE_Event_Handler *  event_handler, const void *  arg, const ACE_Time_Value &  delay, const ACE_Time_Value &  interval = ACE_Time_Value::zero )  [virtual]

Schedule an ACE_Event_Handler that will expire after an amount of time. The return value of this method, a timer_id value, uniquely identifies the event_handler in the ACE_Reactor's internal list of timers. This timer_id value can be used to cancel the timer with the cancel_timer() call. See also: cancel_timer() reset_timer_interval() Parameters: event_handler  event handler to schedule on reactor arg  argument passed to the handle_timeout() method of event_handler. delay  time interval after which the timer will expire. interval  time interval for which the timer will be automatically rescheduled. Returns: -1 on failure, a timer_id value on success Implements ACE_Reactor_Impl. Definition at line 2024 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ESHUTDOWN, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule(), and timer_queue_. { ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_timer"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); if (0 != this->timer_queue_) return this->timer_queue_->schedule (event_handler, arg, this->timer_queue_->gettimeofday () + delay, interval); errno = ESHUTDOWN; return -1; }

int ACE_Dev_Poll_Reactor::schedule_wakeup (  ACE_HANDLE  handle, ACE_Reactor_Mask  masks_to_be_added )  [virtual]

Add to the 's entry. associated with must already have been registered. Implements ACE_Reactor_Impl. Definition at line 2099 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, and mask_ops(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_wakeup"); return this->mask_ops (handle, mask, ACE_Reactor::ADD_MASK); }

int ACE_Dev_Poll_Reactor::schedule_wakeup (  ACE_Event_Handler *  event_handler, ACE_Reactor_Mask  masks_to_be_added )  [virtual]

Add to the 's entry. must already have been registered. Implements ACE_Reactor_Impl. Definition at line 2090 of file Dev_Poll_Reactor.cpp. References ACE_Reactor_Mask, ACE_TRACE, ACE_Event_Handler::get_handle(), and mask_ops(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_wakeup"); return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::ADD_MASK); }

int ACE_Dev_Poll_Reactor::set_sig_handler (  ACE_Sig_Handler *  signal_handler  )  [virtual]

Use a user specified signal handler instead. Implements ACE_Reactor_Impl. Definition at line 947 of file Dev_Poll_Reactor.cpp. References delete_signal_handler_, and signal_handler_. { if (this->delete_signal_handler_ && this->signal_handler_) delete this->signal_handler_; this->signal_handler_ = signal_handler; this->delete_signal_handler_ = 0; return 0; }

size_t ACE_Dev_Poll_Reactor::size (  void   )  const [virtual]

Returns the current size of the Reactor's internal descriptor table. Implements ACE_Reactor_Impl. Definition at line 2236 of file Dev_Poll_Reactor.cpp. { return this->size_; }

int ACE_Dev_Poll_Reactor::suspend_handler (  const ACE_Handle_Set &  handles  )  [virtual]

Suspend all handles in handle set temporarily. Implements ACE_Reactor_Impl. Definition at line 1817 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, and suspend_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); ACE_Handle_Set_Iterator handle_iter (handles); ACE_HANDLE h; ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); while ((h = handle_iter ()) != ACE_INVALID_HANDLE) if (this->suspend_handler_i (h) == -1) return -1; return 0; }

int ACE_Dev_Poll_Reactor::suspend_handler (  ACE_HANDLE  handle  )  [virtual]

Suspend handle temporarily. Implements ACE_Reactor_Impl. Definition at line 1807 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, and suspend_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->suspend_handler_i (handle); }

int ACE_Dev_Poll_Reactor::suspend_handler (  ACE_Event_Handler *  event_handler  )  [virtual]

Suspend event_handler temporarily. Use ACE_Event_Handler::get_handle() to get the handle. Implements ACE_Reactor_Impl. Definition at line 1789 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, ACE_Event_Handler::get_handle(), and suspend_handler_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); if (event_handler == 0) { errno = EINVAL; return -1; } ACE_HANDLE handle = event_handler->get_handle (); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); return this->suspend_handler_i (handle); }

int ACE_Dev_Poll_Reactor::suspend_handler_i (  ACE_HANDLE  handle  )  [protected]

Temporarily remove the given handle from the "interest set.". Definition at line 1851 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Dev_Poll_Reactor_Handler_Repository::find(), handler_rep_, ACE_OS::memset(), poll_fd_, ACE_Dev_Poll_Reactor_Handler_Repository::suspend(), ACE_Dev_Poll_Reactor_Handler_Repository::suspended(), and ACE_OS::write(). Referenced by suspend_handler(), and suspend_handlers(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler_i"); if (this->handler_rep_.find (handle) == 0) return -1; if (this->handler_rep_.suspended (handle)) return 0; // Already suspended. @@ Should this be an error? // Remove the handle from the "interest set." // // Note that the associated event handler is still in the handler // repository, but no events will be polled on the given handle thus // no event will be dispatched to the event handler. #if defined (ACE_HAS_EVENT_POLL) struct epoll_event epev; ACE_OS::memset (&epev, 0, sizeof (epev)); static const int op = EPOLL_CTL_DEL; epev.events = 0; epev.data.fd = handle; if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) return -1; #else struct pollfd pfd[1]; pfd[0].fd = handle; pfd[0].events = POLLREMOVE; pfd[0].revents = 0; if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) return -1; #endif /* ACE_HAS_EVENT_POLL */ this->handler_rep_.suspend (handle); return 0; }

int ACE_Dev_Poll_Reactor::suspend_handlers (  void   )  [virtual]

Suspend all handles temporarily. Implements ACE_Reactor_Impl. Definition at line 1834 of file Dev_Poll_Reactor.cpp. References ACE_Dev_Poll_Reactor_Token, ACE_GUARD_RETURN, ACE_TRACE, handler_rep_, ACE_Dev_Poll_Reactor_Handler_Repository::size(), suspend_handler_i(), and ACE_Dev_Poll_Reactor_Handler_Repository::suspended(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handlers"); ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); const size_t len = this->handler_rep_.size (); for (size_t i = 0; i < len; ++i) if (this->handler_rep_.suspended (i) == 0 && this->suspend_handler_i (i) != 0) return -1; return 0; }

ACE_Timer_Queue * ACE_Dev_Poll_Reactor::timer_queue (  void   )  const [virtual]

Get the timer queue Returns: The current ACE_Timer_Queue. Implements ACE_Reactor_Impl. Definition at line 972 of file Dev_Poll_Reactor.cpp. References timer_queue_. { return this->timer_queue_; }

int ACE_Dev_Poll_Reactor::timer_queue (  ACE_Timer_Queue *  tq  )  [virtual]

Set a user-specified timer queue. Implements ACE_Reactor_Impl. Definition at line 959 of file Dev_Poll_Reactor.cpp. References ACE_Timer_Queue, delete_timer_queue_, and timer_queue_. { if (this->delete_timer_queue_ && this->timer_queue_) delete this->timer_queue_; this->timer_queue_ = tq; this->delete_timer_queue_ = 0; return 0; }

ACE_INLINE int ACE_Dev_Poll_Reactor::upcall (  ACE_Event_Handler *  event_handler, int(ACE_Event_Handler::*  callback)(ACE_HANDLE), ACE_HANDLE  handle )  [protected]

Perform the upcall with the given event handler method. Definition at line 169 of file Dev_Poll_Reactor.inl. Referenced by dispatch_io_event(). { // If the handler returns positive value (requesting a reactor // callback) just call back as many times as the handler requests // it. Other threads are off handling other things. int status = 0; do { status = (event_handler->*callback) (handle); } while (status > 0); return status; }

int ACE_Dev_Poll_Reactor::uses_event_associations (  void   )  [virtual]

Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. Implements ACE_Reactor_Impl. Definition at line 2016 of file Dev_Poll_Reactor.cpp. { // Since the Dev_Poll_Reactor does not do any event associations, // this method always return zero. return 0; }

void ACE_Dev_Poll_Reactor::wakeup_all_threads (  void   )  [virtual]

Wake up all threads waiting in the event loop. Implements ACE_Reactor_Impl. Definition at line 2250 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and notify(). Referenced by deactivate(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::wakeup_all_threads"); // Send a notification, but don't block if there's no one to receive // it. this->notify (0, ACE_Event_Handler::NULL_MASK, (ACE_Time_Value *) &ACE_Time_Value::zero); }

int ACE_Dev_Poll_Reactor::work_pending (  const ACE_Time_Value &  max_wait_time = ACE_Time_Value::zero  )  [virtual]

Returns non-zero if there are I/O events "ready" for dispatching, but does not actually dispatch the event handlers. By default, don't block while checking this, i.e., "poll". Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl. Definition at line 1045 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Dev_Poll_Reactor::Token_Guard::acquire_quietly(), ACE_Dev_Poll_Reactor::Token_Guard::is_owner(), and work_pending_i(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::work_pending"); // Stash the current time // // The destructor of this object will automatically compute how much // time elapsed since this method was called. ACE_Time_Value mwt (max_wait_time); ACE_MT (ACE_Countdown_Time countdown (&mwt)); Token_Guard guard (this->token_); int result = guard.acquire_quietly (&mwt); // If the guard is NOT the owner just return the retval if (!guard.is_owner ()) return result; // Update the countdown to reflect time waiting for the mutex. ACE_MT (countdown.update ()); return this->work_pending_i (&mwt); }

int ACE_Dev_Poll_Reactor::work_pending_i (  ACE_Time_Value *  max_wait_time  )  [protected]

Non-locking version of wait_pending(). Returns non-zero if there are I/O events "ready" for dispatching, but does not actually dispatch the event handlers. By default, don't block while checking this, i.e., "poll". Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Definition at line 1070 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout(), deactivated_, end_pevents_, events_, ACE_OS::ioctl(), poll_fd_, start_pevents_, and timer_queue_. Referenced by handle_events_i(), and work_pending(). { ACE_TRACE ("ACE_Dev_Poll_Reactor::work_pending_i"); if (this->deactivated_) return 0; #if defined (ACE_HAS_EVENT_POLL) if (this->start_pevents_ != this->end_pevents_) #else if (this->start_pfds_ != this->end_pfds_) #endif /* ACE_HAS_EVENT_POLL */ return 1; // We still have work_pending(). Do not poll for // additional events. ACE_Time_Value timer_buf (0); ACE_Time_Value *this_timeout = 0; this_timeout = this->timer_queue_->calculate_timeout (max_wait_time, &timer_buf); // Check if we have timers to fire. const int timers_pending = ((this_timeout != 0 && max_wait_time == 0) || (this_timeout != 0 && max_wait_time != 0 && *this_timeout != *max_wait_time) ? 1 : 0); const long timeout = (this_timeout == 0 ? -1 /* Infinity */ : static_cast<long> (this_timeout->msec ())); #if defined (ACE_HAS_EVENT_POLL) // Wait for events. const int nfds = ::epoll_wait (this->poll_fd_, this->events_, this->size_, static_cast<int> (timeout)); if (nfds > 0) { this->start_pevents_ = this->events_; this->end_pevents_ = this->start_pevents_ + nfds; } #else struct dvpoll dvp; dvp.dp_fds = this->dp_fds_; dvp.dp_nfds = this->size_; dvp.dp_timeout = timeout; // Milliseconds // Poll for events const int nfds = ACE_OS::ioctl (this->poll_fd_, DP_POLL, &dvp); // Retrieve the results from the pollfd array. this->start_pfds_ = dvp.dp_fds; // If nfds == 0 then end_pfds_ == start_pfds_ meaning that there is // no work pending. If nfds > 0 then there is work pending. // Otherwise an error occurred. if (nfds > -1) this->end_pfds_ = this->start_pfds_ + nfds; #endif /* ACE_HAS_EVENT_POLL */ // If timers are pending, override any timeout from the poll. return (nfds == 0 && timers_pending != 0 ? 1 : nfds); }

---

Member Data Documentation

ACE_Dev_Poll_Reactor::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Reimplemented from ACE_Reactor_Impl. Definition at line 986 of file Dev_Poll_Reactor.h.

sig_atomic_t ACE_Dev_Poll_Reactor::deactivated_ [protected]

This flag is used to keep track of whether we are actively handling events or not. Definition at line 1118 of file Dev_Poll_Reactor.h. Referenced by deactivate(), deactivated(), handle_events(), and work_pending_i().

int ACE_Dev_Poll_Reactor::delete_notify_handler_ [protected]

Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it). Definition at line 1149 of file Dev_Poll_Reactor.h. Referenced by close(), and open().

int ACE_Dev_Poll_Reactor::delete_signal_handler_ [protected]

Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it). Definition at line 1141 of file Dev_Poll_Reactor.h. Referenced by close(), open(), and set_sig_handler().

int ACE_Dev_Poll_Reactor::delete_timer_queue_ [protected]

Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it). Definition at line 1134 of file Dev_Poll_Reactor.h. Referenced by close(), open(), and timer_queue().

struct epoll_event* ACE_Dev_Poll_Reactor::end_pevents_ [protected]

The last element in the event array plus one. The loop that dispatches IO events stops when this->start_pevents_ == this->end_pevents_. Definition at line 1097 of file Dev_Poll_Reactor.h. Referenced by close(), dispatch_io_event(), and work_pending_i().

struct epoll_event* ACE_Dev_Poll_Reactor::events_ [protected]

Table of event structures to be filled by epoll_wait:. Track HANDLES we are interested in for various events that must be dispatched *without* polling. ACE_Dev_Poll_Ready_Set ready_set_; Definition at line 1086 of file Dev_Poll_Reactor.h. Referenced by close(), and work_pending_i().

ACE_Dev_Poll_Reactor_Handler_Repository ACE_Dev_Poll_Reactor::handler_rep_ [protected]

The repository that contains all registered event handlers. Definition at line 1127 of file Dev_Poll_Reactor.h. Referenced by close(), dispatch_io_event(), find_handler(), handler(), mask_ops_i(), open(), register_handler_i(), remove_handler_i(), resume_handler_i(), resume_handlers(), suspend_handler_i(), and suspend_handlers().

bool ACE_Dev_Poll_Reactor::initialized_ [protected]

Has the reactor been initialized. Definition at line 1066 of file Dev_Poll_Reactor.h. Referenced by close(), initialized(), and open().

ACE_Lock_Adapter<ACE_Dev_Poll_Reactor_Token> ACE_Dev_Poll_Reactor::lock_adapter_ [protected]

Adapter used to return internal lock to outside world. Definition at line 1124 of file Dev_Poll_Reactor.h. Referenced by lock().

int ACE_Dev_Poll_Reactor::mask_signals_ [protected]

If 0 then the Reactor will not mask the signals during the event dispatching. This is useful for applications that do not register any signal handlers and want to reduce the overhead introduce by the kernel level locks required to change the mask. Definition at line 1159 of file Dev_Poll_Reactor.h.

ACE_Reactor_Notify* ACE_Dev_Poll_Reactor::notify_handler_ [protected]

Callback object that unblocks the if it's sleeping. Definition at line 1145 of file Dev_Poll_Reactor.h. Referenced by close(), max_notify_iterations(), notify(), open(), and purge_pending_notifications().

ACE_HANDLE ACE_Dev_Poll_Reactor::poll_fd_ [protected]

All interactions with the `/dev/poll' or `/dev/epoll' device are done through this file descriptor. Definition at line 1074 of file Dev_Poll_Reactor.h. Referenced by close(), mask_ops_i(), open(), register_handler_i(), resume_handler_i(), suspend_handler_i(), and work_pending_i().

int ACE_Dev_Poll_Reactor::restart_ [protected]

Restart the handle_events event loop method automatically when polling function in use (ioctl() in this case) is interrupted via an EINTR signal. Definition at line 1164 of file Dev_Poll_Reactor.h.

ACE_Sig_Handler* ACE_Dev_Poll_Reactor::signal_handler_ [protected]

Handle signals without requiring global/static variables. Definition at line 1137 of file Dev_Poll_Reactor.h. Referenced by close(), handler(), open(), register_handler(), remove_handler(), and set_sig_handler().

size_t ACE_Dev_Poll_Reactor::size_ [protected]

The maximum number of file descriptors over which demultiplexing will occur. Definition at line 1078 of file Dev_Poll_Reactor.h.

struct epoll_event* ACE_Dev_Poll_Reactor::start_pevents_ [protected]

Pointer to the next epoll_event array element that contains the next event to be dispatched. Definition at line 1090 of file Dev_Poll_Reactor.h. Referenced by close(), dispatch_io_event(), and work_pending_i().

ACE_Timer_Queue* ACE_Dev_Poll_Reactor::timer_queue_ [protected]

Defined as a pointer to allow overriding by derived classes... Definition at line 1130 of file Dev_Poll_Reactor.h. Referenced by cancel_timer(), close(), dispatch_timer_handler(), open(), reset_timer_interval(), schedule_timer(), timer_queue(), and work_pending_i().

ACE_Dev_Poll_Reactor_Token ACE_Dev_Poll_Reactor::token_ [protected]

Lock used for synchronization of reactor state. Definition at line 1121 of file Dev_Poll_Reactor.h.

---

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

• Dev_Poll_Reactor.h
• Dev_Poll_Reactor.cpp
• Dev_Poll_Reactor.inl

---