ACE  6.1.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
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:
Inheritance graph
[legend]
Collaboration diagram for ACE_Dev_Poll_Reactor:
Collaboration graph
[legend]

Classes

struct  Event_Tuple
 Struct that collects event registration information for a handle. More...
 
class  Handler_Repository
 Used to map ACE_HANDLEs onto the appropriate Event_Tuple. More...
 
class  Token_Guard
 A helper class that helps grabbing, releasing and waiting on tokens for a thread that needs access to the reactor's token. More...
 

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, bool restart=false, 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, bool restart=false, 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_Queuetimer_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 <remove_handler> for every signal in sigset.
 
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 bool 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 masks_to_be_cleared from the event_handler's entry.
 
virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared)
 Clear masks_to_be_cleared from the handle'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_Handlerfind_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 bool initialized (void)
 
virtual size_t size (void) const
 
virtual ACE_Locklock (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 bool restart (void)
 Get the existing restart value.
 
virtual bool restart (bool 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 Member Functions inherited from ACE_Reactor_Impl
virtual ~ACE_Reactor_Impl (void)
 Close down and release all resources.
 
virtual int register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)=0
 

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.
 
- Public Attributes inherited from ACE_Reactor_Impl
 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, ACE_Event_Handler *eh=0)
 
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_
 
struct pollfd * dp_fds_
 The pollfd array that `/dev/poll' will feed its results to.
 
struct pollfd * start_pfds_
 
struct pollfd * end_pfds_
 The last element in the pollfd 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.
 
Handler_Repository handler_rep_
 The repository that contains all registered event handlers.
 
ACE_Timer_Queuetimer_queue_
 Defined as a pointer to allow overriding by derived classes...
 
bool delete_timer_queue_
 
ACE_Sig_Handlersignal_handler_
 Handle signals without requiring global/static variables.
 
bool delete_signal_handler_
 
ACE_Reactor_Notifynotify_handler_
 
bool delete_notify_handler_
 
int mask_signals_
 
bool restart_
 

Detailed Description

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

Attention
The Linux epoll implementation works quite well and is fully supported; however, the /dev/poll implementation 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.

Constructor & Destructor Documentation

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

ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor ( size_t  size,
bool  restart = false,
ACE_Sig_Handler sh = 0,
ACE_Timer_Queue tq = 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.
ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor ( void  )
virtual

Close down and release all resources.

Member Function Documentation

int ACE_Dev_Poll_Reactor::alertable_handle_events ( ACE_Time_Value max_wait_time = 0)
virtual

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::alertable_handle_events ( ACE_Time_Value max_wait_time)
virtual

Implements ACE_Reactor_Impl.

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 event_handler. Returns number of handlers cancelled.

Implements ACE_Reactor_Impl.

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.

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

Clear masks_to_be_cleared from the event_handler's entry.

Implements ACE_Reactor_Impl.

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

Clear masks_to_be_cleared from the handle's entry.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::close ( void  )
virtual

Close down and release all resources.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::current_info ( ACE_HANDLE  handle,
size_t &   
)
virtual
Parameters
handleallows 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.

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.

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.

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.

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

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

void ACE_Dev_Poll_Reactor::dump ( void  ) const
virtual

Dump the state of an object.

Implements ACE_Reactor_Impl.

ACE_Event_Handler * ACE_Dev_Poll_Reactor::find_handler ( ACE_HANDLE  handle)
virtual

Return the Event_Handler associated with handle. Return 0 if handle is not registered.

Implements ACE_Reactor_Impl.

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.

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.

int ACE_Dev_Poll_Reactor::handle_events_i ( ACE_Time_Value max_wait_time,
Token_Guard guard 
)
protected

Poll for events and return the number of event handlers that were dispatched. This is a helper method called by all handle_events() methods.

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

Check to see if handle is associated with a valid Event_Handler bound to mask. Return the event_handler associated with this handler if event_handler != 0.

Implements ACE_Reactor_Impl.

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

Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the event_handler associated with this handler if event_handler != 0.

Implements ACE_Reactor_Impl.

bool ACE_Dev_Poll_Reactor::initialized ( void  )
virtual

Returns true if Reactor has been successfully initialized, else false.

Implements ACE_Reactor_Impl.

ACE_Lock & ACE_Dev_Poll_Reactor::lock ( void  )
virtual

Returns a reference to the Reactor's internal lock.

Implements ACE_Reactor_Impl.

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

GET/SET/ADD/CLR the dispatch mask "bit" bound with the event_handler and mask.

Returns
Old mask on success, -1 on error.

Implements ACE_Reactor_Impl.

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

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.

Returns
Old mask on success, -1 on error.

Implements ACE_Reactor_Impl.

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

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask. This internal helper method acquires no lock.

Returns
Old mask on success, -1 on error.

Reset the mask for the given handle.

void ACE_Dev_Poll_Reactor::max_notify_iterations ( int  iterations)
virtual

Set the maximum number of times that ACE_Reactor_Impl will iterate and dispatch the ACE_Event_Handlers 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.

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 ACE_Event_Handlers that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop.

Implements ACE_Reactor_Impl.

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

Notify event_handler of mask event. The ACE_Time_Value indicates how long to blocking trying to notify. If timeout == 0, the caller will block until action is possible, else will wait until the relative time specified in timeout elapses).

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::open ( size_t  size,
bool  restart = false,
ACE_Sig_Handler sh = 0,
ACE_Timer_Queue tq = 0,
int  disable_notify_pipe = 0,
ACE_Reactor_Notify notify = 0 
)
virtual

Initialization.

Implements ACE_Reactor_Impl.

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.

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 simultaneously. As such, this method is a no-op.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::purge_pending_notifications ( ACE_Event_Handler eh = 0,
ACE_Reactor_Mask  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.

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.

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.

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.

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.

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.

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.

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.

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.

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 new_sh to handle a set of signals sigset using the new_disp.

Implements ACE_Reactor_Impl.

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.

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.

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

Removes handle. If mask == ACE_Event_Handler::DONT_CALL then the <handle_close> method of the associated <event_handler> is not invoked.

Implements ACE_Reactor_Impl.

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

Removes all handles in handle_set. If mask == ACE_Event_Handler::DONT_CALL then the <handle_close> method of the associated <event_handler>s is not invoked.

Implements ACE_Reactor_Impl.

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 signum. Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if signum is invalid.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::remove_handler ( const ACE_Sig_Set sigset)
virtual

Calls <remove_handler> for every signal in sigset.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::remove_handler_i ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Event_Handler eh = 0 
)
protected

Remove the event handler associated with the given handle and event mask from the "interest set." If eh is supplied, only do the remove if matches the event handler that's registered for handle.

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.

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.

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 timer_id to interval, which is specified in relative time to the current <gettimeofday>. If interval 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.

bool ACE_Dev_Poll_Reactor::restart ( void  )
virtual

Get the existing restart value.

Implements ACE_Reactor_Impl.

bool ACE_Dev_Poll_Reactor::restart ( bool  r)
virtual

Set a new value for restart and return the original value.

Parameters
rIf 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.

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.

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.

int ACE_Dev_Poll_Reactor::resume_handler ( ACE_HANDLE  handle)
virtual

Resume handle.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::resume_handler ( const ACE_Handle_Set handles)
virtual

Resume all handles in handle set.

Implements ACE_Reactor_Impl.

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.

int ACE_Dev_Poll_Reactor::resume_handlers ( void  )
virtual

Resume all handles.

Implements ACE_Reactor_Impl.

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_handlerevent handler to schedule on reactor
argargument passed to the handle_timeout() method of event_handler.
delaytime interval after which the timer will expire.
intervaltime interval for which the timer will be automatically rescheduled.
Returns
-1 on failure, a timer_id value on success

Implements ACE_Reactor_Impl.

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

Add masks_to_be_added to the event_handler's entry. event_handler must already have been registered.

Implements ACE_Reactor_Impl.

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

Add masks_to_be_added to the handle's entry. <event_handler> associated with handle must already have been registered.

Implements ACE_Reactor_Impl.

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.

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.

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.

int ACE_Dev_Poll_Reactor::suspend_handler ( ACE_HANDLE  handle)
virtual

Suspend handle temporarily.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler ( const ACE_Handle_Set handles)
virtual

Suspend all handles in handle set temporarily.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler_i ( ACE_HANDLE  handle)
protected

Temporarily remove the given handle from the "interest set.".

int ACE_Dev_Poll_Reactor::suspend_handlers ( void  )
virtual

Suspend all handles temporarily.

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::timer_queue ( ACE_Timer_Queue tq)
virtual

Set a user-specified timer queue.

Implements ACE_Reactor_Impl.

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.

int ACE_Dev_Poll_Reactor::upcall ( ACE_Event_Handler event_handler,
int(ACE_Event_Handler::*)(ACE_HANDLE)  callback,
ACE_HANDLE  handle 
)
inlineprotected

Perform the upcall with the given event handler method.

bool ACE_Dev_Poll_Reactor::uses_event_associations ( void  )
virtual

Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise.

Implements ACE_Reactor_Impl.

void ACE_Dev_Poll_Reactor::wakeup_all_threads ( void  )
virtual

Wake up all threads waiting in the event loop.

Implements ACE_Reactor_Impl.

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.

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.

Member Data Documentation

ACE_Dev_Poll_Reactor::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

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.

bool 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).

bool 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).

bool 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).

struct pollfd* ACE_Dev_Poll_Reactor::dp_fds_
protected

The pollfd array that `/dev/poll' will feed its results to.

struct pollfd* ACE_Dev_Poll_Reactor::end_pfds_
protected

The last element in the pollfd array plus one.

The loop that dispatches IO events stops when this->start_pfds == this->end_pfds_.

Handler_Repository ACE_Dev_Poll_Reactor::handler_rep_
protected

The repository that contains all registered event handlers.

bool ACE_Dev_Poll_Reactor::initialized_
protected

Has the reactor been initialized.

ACE_Lock_Adapter<ACE_Dev_Poll_Reactor_Token> ACE_Dev_Poll_Reactor::lock_adapter_
protected

Adapter used to return internal lock to outside world.

int ACE_Dev_Poll_Reactor::mask_signals_
protected

Flag that determines if signals are masked during event dispatching. 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.

ACE_Reactor_Notify* ACE_Dev_Poll_Reactor::notify_handler_
protected

Callback object that unblocks the <ACE_Select_Reactor> if it's sleeping.

ACE_HANDLE ACE_Dev_Poll_Reactor::poll_fd_
protected

The file descriptor associated with the open `/dev/poll' or `/dev/epoll' device. All interactions with the `/dev/poll' or `/dev/epoll' device are done through this file descriptor.

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

ACE_Sig_Handler* ACE_Dev_Poll_Reactor::signal_handler_
protected

Handle signals without requiring global/static variables.

struct pollfd* ACE_Dev_Poll_Reactor::start_pfds_
protected

Pointer to the next pollfd array element that contains the next event to be dispatched.

ACE_Timer_Queue* ACE_Dev_Poll_Reactor::timer_queue_
protected

Defined as a pointer to allow overriding by derived classes...

ACE_Dev_Poll_Reactor_Token ACE_Dev_Poll_Reactor::token_
protected

Lock used for synchronization of reactor state.


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