---

ACE_Dev_Poll_Reactor_Notify Class Reference

Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop. More...

#include <Dev_Poll_Reactor.h>

Inheritance diagram for ACE_Dev_Poll_Reactor_Notify:

[legend]Collaboration diagram for ACE_Dev_Poll_Reactor_Notify:

[legend]List of all members.

Public Methods
	ACE_Dev_Poll_Reactor_Notify (void)
	Constructor. More...
virtual int	open (ACE_Reactor_Impl *, ACE_Timer_Queue *timer_queue=0, int disable_notify=0)
virtual int	close (void)
virtual ssize_t	notify (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0)
virtual int	dispatch_notifications (int &number_of_active_handles, ACE_Handle_Set &rd_mask)
	Unimplemented method required by pure virtual method in abstract base class. More...
virtual ACE_HANDLE	notify_handle (void)
	Returns the ACE_HANDLE of the notify pipe on which the reactor is listening for notifications so that other threads can unblock the Reactor_Impl. More...
virtual int	is_dispatchable (ACE_Notification_Buffer &buffer)
	Verify whether the buffer has dispatchable info or not. More...
virtual int	dispatch_notify (ACE_Notification_Buffer &buffer)
	Handle one of the notify call on the handle. This could be because of a thread trying to unblock the Reactor_Impl. More...
virtual int	read_notify_pipe (ACE_HANDLE handle, ACE_Notification_Buffer &buffer)
	Read one of the notify call on the handle into the buffer. This could be because of a thread trying to unblock the Reactor_Impl. More...
virtual int	handle_input (ACE_HANDLE handle)
	Called back by the ACE_Dev_Poll_Reactor when a thread wants to unblock us. More...
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 void	dump (void) const
	Dump the state of an object. More...
Protected Attributes
ACE_Dev_Poll_Reactor *	dp_reactor_
ACE_Pipe	notification_pipe_
int	max_notify_iterations_

---

Detailed Description

Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop.

This event handler is used internally by the ACE_Dev_Poll_Reactor as a means to allow a thread other then the one running the event loop to unblock the event loop.

Definition at line 153 of file Dev_Poll_Reactor.h.

---

Constructor & Destructor Documentation

ACE_Dev_Poll_Reactor_Notify::ACE_Dev_Poll_Reactor_Notify (  void    )

Constructor. Definition at line 50 of file Dev_Poll_Reactor.cpp. : dp_reactor_ (0) , notification_pipe_ () , max_notify_iterations_ (-1) #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) , alloc_queue_ () , notify_queue_ () , free_queue_ () , notify_queue_lock_ () #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ { }

---

Member Function Documentation

int ACE_Dev_Poll_Reactor_Notify::close (  void    )  [virtual]

Implements ACE_Reactor_Notify. Definition at line 117 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, ACE_Unbounded_Queue_Iterator::advance, ACE_Pipe::close, ACE_Unbounded_Queue_Iterator::next, and notification_pipe_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::close"); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // Free up the dynamically allocated resources. ACE_Notification_Buffer **b; for (ACE_Unbounded_Queue_Iterator<ACE_Notification_Buffer *> alloc_iter (this->alloc_queue_); alloc_iter.next (b) != 0; alloc_iter.advance ()) { delete [] *b; *b = 0; } this->alloc_queue_.reset (); this->notify_queue_.reset (); this->free_queue_.reset (); #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ return this->notification_pipe_.close (); }

int ACE_Dev_Poll_Reactor_Notify::dispatch_notifications (  int &    number_of_active_handles, ACE_Handle_Set &    rd_mask )  [virtual]

Unimplemented method required by pure virtual method in abstract base class. This method's interface is not very compatibile with this Reactor's design. It's not clear why this method is pure virtual either. Implements ACE_Reactor_Notify. Definition at line 221 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, handle_input, notification_pipe_, and ACE_Pipe::read_handle. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notifications"); // This method is unimplemented in the ACE_Dev_Poll_Reactor. // Instead, the notification handler is invoked as part of the IO // event set. Doing so alters the some documented semantics that // state that the notifications are handled before IO events. // Enforcing such semantics does not appear to be beneficial, and // also serves to slow down event dispatching particularly with this // ACE_Dev_Poll_Reactor. #if 0 ACE_HANDLE read_handle = this->notification_pipe_.read_handle (); // Note that we do not check if the handle has received any events. // Instead a non-blocking "speculative" read is performed. If the // read returns with errno == EWOULDBLOCK then no notifications are // dispatched. See ACE_Dev_Poll_Reactor_Notify::read_notify_pipe() // for details. if (read_handle != ACE_INVALID_HANDLE) { number_of_active_handles--; return this->handle_input (read_handle); } else return 0; #else ACE_NOTSUP_RETURN (-1); #endif /* 0 */ }

int ACE_Dev_Poll_Reactor_Notify::dispatch_notify (  ACE_Notification_Buffer &    buffer )  [virtual]

Handle one of the notify call on the handle. This could be because of a thread trying to unblock the Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 366 of file Dev_Poll_Reactor.cpp. References ACE_Event_Handler::ACCEPT_MASK, ACE_ERROR, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_SYNCH_MUTEX, ACE_TRACE, ACE_Notification_Buffer::eh_, ACE_Event_Handler::EXCEPT_MASK, ACE_Event_Handler::GROUP_QOS_MASK, ACE_Event_Handler::handle_close, ACE_Event_Handler::handle_exception, ACE_Event_Handler::handle_group_qos, ACE_Event_Handler::handle_input, ACE_Event_Handler::handle_output, ACE_Event_Handler::handle_qos, LM_ERROR, ACE_Notification_Buffer::mask_, ACE_Event_Handler::QOS_MASK, ACE_Event_Handler::READ_MASK, and ACE_Event_Handler::WRITE_MASK. Referenced by handle_input. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notify"); int result = 0; #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) // Dispatch all messages that are in the <notify_queue_>. { // We acquire the lock in a block to make sure we're not // holding the lock while delivering callbacks... ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); ACE_Notification_Buffer *temp; if (notify_queue_.is_empty ()) return 0; else if (notify_queue_.dequeue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); buffer = *temp; if (free_queue_.enqueue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); } // If eh == 0 then another thread is unblocking the // ACE_Dev_Poll_Reactor to update the ACE_Dev_Poll_Reactor's // internal structures. Otherwise, we need to dispatch the // appropriate handle_* method on the ACE_Event_Handler // pointer we've been passed. if (buffer.eh_ != 0) { switch (buffer.mask_) { case ACE_Event_Handler::READ_MASK: case ACE_Event_Handler::ACCEPT_MASK: result = buffer.eh_->handle_input (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::WRITE_MASK: result = buffer.eh_->handle_output (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::EXCEPT_MASK: result = buffer.eh_->handle_exception (ACE_INVALID_HANDLE); break; default: // Should we bail out if we get an invalid mask? ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("invalid mask = %d\n"), buffer.mask_)); } if (result == -1) buffer.eh_->handle_close (ACE_INVALID_HANDLE, ACE_Event_Handler::EXCEPT_MASK); } #else // If eh == 0 then another thread is unblocking the // ACE_Dev_Poll_Reactor to update the ACE_Dev_Poll_Reactor's // internal structures. Otherwise, we need to dispatch the // appropriate handle_* method on the ACE_Event_Handler // pointer we've been passed. if (buffer.eh_ != 0) { switch (buffer.mask_) { case ACE_Event_Handler::READ_MASK: case ACE_Event_Handler::ACCEPT_MASK: result = buffer.eh_->handle_input (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::WRITE_MASK: result = buffer.eh_->handle_output (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::EXCEPT_MASK: result = buffer.eh_->handle_exception (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::QOS_MASK: result = buffer.eh_->handle_qos (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::GROUP_QOS_MASK: result = buffer.eh_->handle_group_qos (ACE_INVALID_HANDLE); break; default: // Should we bail out if we get an invalid mask? ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("invalid mask = %d\n"), buffer.mask_)); } if (result == -1) buffer.eh_->handle_close (ACE_INVALID_HANDLE, ACE_Event_Handler::EXCEPT_MASK); } #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ return 1; }

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

Dump the state of an object. Implements ACE_Reactor_Notify. Definition at line 583 of file Dev_Poll_Reactor.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_Pipe::dump, LM_DEBUG, and notification_pipe_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("dp_reactor_ = 0x%x"), this->dp_reactor_)); this->notification_pipe_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }

int ACE_Dev_Poll_Reactor_Notify::handle_input (  ACE_HANDLE    handle )  [virtual]

Called back by the ACE_Dev_Poll_Reactor when a thread wants to unblock us. Reimplemented from ACE_Event_Handler. Definition at line 303 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, dispatch_notify, EWOULDBLOCK, max_notify_iterations_, and read_notify_pipe. Referenced by dispatch_notifications. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::handle_input"); // @@ We may end up dispatching this event handler twice: once when // performing the speculative read on the notification pipe // handle, and once more when dispatching the IO events. // Precondition: this->select_reactor_.token_.current_owner () == // ACE_Thread::self (); int number_dispatched = 0; int result = 0; ACE_Notification_Buffer buffer; while ((result = this->read_notify_pipe (handle, buffer)) > 0) { // Dispatch the buffer // NOTE: We count only if we made any dispatches ie. upcalls. if (this->dispatch_notify (buffer) > 0) number_dispatched++; // Bail out if we've reached the <notify_threshold_>. Note that // by default <notify_threshold_> is -1, so we'll loop until all // the notifications in the pipe have been dispatched. if (number_dispatched == this->max_notify_iterations_) break; } if ((result == -1 && (errno != EWOULDBLOCK || errno != EAGAIN)) || result == 0) { // Reassign number_dispatched to -1 if things have gone // seriously wrong. number_dispatched = -1; } // Enqueue ourselves into the list of waiting threads. When we // reacquire the token we'll be off and running again with ownership // of the token. The postcondition of this call is that // <select_reactor_.token_.current_owner> == <ACE_Thread::self>. //this->select_reactor_->renew (); return number_dispatched; }

int ACE_Dev_Poll_Reactor_Notify::is_dispatchable (  ACE_Notification_Buffer &    buffer )  [virtual]

Verify whether the buffer has dispatchable info or not. Implements ACE_Reactor_Notify. Definition at line 358 of file Dev_Poll_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::is_dispatchable"); ACE_NOTSUP_RETURN (-1); }

int ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (  void    )  [virtual]

Get the maximum number of times that the handle_input method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of its event loop. Implements ACE_Reactor_Notify. Definition at line 481 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and max_notify_iterations_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::max_notify_iterations"); return this->max_notify_iterations_; }

void ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (  int    )  [virtual]

Set the maximum number of times that the handle_input method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of the event 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_Notify. Definition at line 469 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, and max_notify_iterations_. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::max_notify_iterations"); // Must always be > 0 or < 0 to optimize the loop exit condition. if (iterations == 0) iterations = 1; this->max_notify_iterations_ = iterations; }

ssize_t ACE_Dev_Poll_Reactor_Notify::notify (  ACE_Event_Handler *    = 0, ACE_Reactor_Mask    = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *    = 0 )  [virtual]

Called by a thread when it wants to unblock the Reactor_Impl. This wakeups the Reactor_Impl if currently blocked. Pass over both the Event_Handler *and* the mask to allow the caller to dictate which Event_Handler method the Reactor_Impl will invoke. The ACE_Time_Value indicates how long to blocking trying to notify the Reactor_Impl. 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_Notify. Definition at line 142 of file Dev_Poll_Reactor.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_Reactor_Mask, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_SYNCH_MUTEX, ACE_TRACE, dp_reactor_, ACE::send, and ssize_t. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify"); // Just consider this method a "no-op" if there's no // ACE_Dev_Poll_Reactor configured. if (this->dp_reactor_ == 0) return 0; #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_Notification_Buffer buffer (eh, mask); // int notification_required = 0; ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); // No pending notifications. // We will send notify for every message.. // if (this->notify_queue_.is_empty ()) // notification_required = 1; ACE_Notification_Buffer *temp = 0; if (free_queue_.dequeue_head (temp) == -1) { // Grow the queue of available buffers. ACE_Notification_Buffer *temp1; ACE_NEW_RETURN (temp1, ACE_Notification_Buffer[ACE_REACTOR_NOTIFICATION_ARRAY_SIZE], -1); if (this->alloc_queue_.enqueue_head (temp1) == -1) return -1; // Start at 1 and enqueue only // (ACE_REACTOR_NOTIFICATION_ARRAY_SIZE - 1) elements since // the first one will be used right now. for (size_t i = 1; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; ++i) this->free_queue_.enqueue_head (temp1 + i); temp = temp1; } ACE_ASSERT (temp != 0); *temp = buffer; if (notify_queue_.enqueue_tail (temp) == -1) return -1; // Let us send a notify for every message // if (notification_required) ssize_t n = ACE::send (this->notification_pipe_.write_handle (), (char *) &buffer, sizeof buffer, timeout); if (n == -1) return -1; return 0; #else ACE_Notification_Buffer buffer (eh, mask); ssize_t n = ACE::send (this->notification_pipe_.write_handle (), (char *) &buffer, sizeof buffer, timeout); if (n == -1) return -1; return 0; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ }

ACE_HANDLE ACE_Dev_Poll_Reactor_Notify::notify_handle (  void    )  [virtual]

Returns the ACE_HANDLE of the notify pipe on which the reactor is listening for notifications so that other threads can unblock the Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 350 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, notification_pipe_, and ACE_Pipe::read_handle. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify_handle"); return this->notification_pipe_.read_handle (); }

int ACE_Dev_Poll_Reactor_Notify::open (  ACE_Reactor_Impl *   , ACE_Timer_Queue *    timer_queue = 0, int    disable_notify = 0 )  [virtual]

Implements ACE_Reactor_Notify. Definition at line 64 of file Dev_Poll_Reactor.cpp. References ACE_NEW_RETURN, ACE_NONBLOCK, ACE_REACTOR_NOTIFICATION_ARRAY_SIZE, ACE_TRACE, dp_reactor_, ACE_OS::fcntl, notification_pipe_, ACE_Pipe::open, and ACE_Flag_Manip::set_flags. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::open"); if (disable_notify_pipe == 0) { this->dp_reactor_ = ACE_dynamic_cast (ACE_Dev_Poll_Reactor *, r); if (this->dp_reactor_ == 0) { errno = EINVAL; return -1; } if (this->notification_pipe_.open () == -1) return -1; #if defined (F_SETFD) // close-on-exec ACE_OS::fcntl (this->notification_pipe_.read_handle (), F_SETFD, 1); ACE_OS::fcntl (this->notification_pipe_.write_handle (), F_SETFD, 1); #endif /* F_SETFD */ #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_Notification_Buffer *temp; ACE_NEW_RETURN (temp, ACE_Notification_Buffer[ACE_REACTOR_NOTIFICATION_ARRAY_SIZE], -1); if (this->alloc_queue_.enqueue_head (temp) == -1) return -1; for (size_t i = 0; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; ++i) if (free_queue_.enqueue_head (temp + i) == -1) return -1; #endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ // Set the read handle into non-blocking mode since we need to // perform a "speculative" read when determining if their are // notifications to dispatch. if (ACE::set_flags (this->notification_pipe_.read_handle (), ACE_NONBLOCK) == -1) return -1; } return 0; }

int ACE_Dev_Poll_Reactor_Notify::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_Notify. Definition at line 489 of file Dev_Poll_Reactor.cpp. References ACE_ASSERT, ACE_BIT_DISABLED, ACE_CLR_BITS, ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_LIB_TEXT, ACE_Reactor_Mask, ACE_SYNCH_MUTEX, ACE_TRACE, ACE_Unbounded_Queue::dequeue_head, ACE_Notification_Buffer::eh_, ACE_Unbounded_Queue::enqueue_head, LM_ERROR, ACE_Notification_Buffer::mask_, and ACE_Unbounded_Queue::size. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::purge_pending_notifications"); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1); if (this->notify_queue_.is_empty ()) return 0; ACE_Notification_Buffer *temp; ACE_Unbounded_Queue <ACE_Notification_Buffer *> local_queue; size_t queue_size = this->notify_queue_.size (); int number_purged = 0; size_t i; for (i = 0; i < queue_size; ++i) { if (-1 == this->notify_queue_.dequeue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); // If this is not a Reactor notify (it is for a particular // handler), and it matches the specified handler (or purging // all), and applying the mask would totally eliminate the // notification, then release it and count the number purged. if ((0 != temp->eh_) && (0 == eh || eh == temp->eh_) && ACE_BIT_DISABLED (temp->mask_, ~mask)) // The existing // notification mask // is left with // nothing when // applying the mask. { if (this->free_queue_.enqueue_head (temp) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); ++number_purged; } else { // To preserve it, move it to the local_queue. // But first, if this is not a Reactor notify (it is for a // particular handler), and it matches the specified handler // (or purging all), then apply the mask. if ((0 != temp->eh_) && (0 == eh || eh == temp->eh_)) ACE_CLR_BITS(temp->mask_, mask); if (-1 == local_queue.enqueue_head (temp)) return -1; } } if (this->notify_queue_.size ()) { // Should be empty! ACE_ASSERT (0); return -1; } // Now put it back in the notify queue. queue_size = local_queue.size (); for (i = 0; i < queue_size; ++i) { if (-1 == local_queue.dequeue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("dequeue_head")), -1); if (-1 == this->notify_queue_.enqueue_head (temp)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_head")), -1); } return number_purged; #else /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ ACE_UNUSED_ARG (eh); ACE_UNUSED_ARG (mask); ACE_NOTSUP_RETURN (-1); #endif /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ }

int ACE_Dev_Poll_Reactor_Notify::read_notify_pipe (  ACE_HANDLE    handle, ACE_Notification_Buffer &    buffer )  [virtual]

Read one of the notify call on the handle into the buffer. This could be because of a thread trying to unblock the Reactor_Impl. Implements ACE_Reactor_Notify. Definition at line 258 of file Dev_Poll_Reactor.cpp. References ACE_TRACE, EWOULDBLOCK, ACE::recv, and ssize_t. Referenced by handle_input. { ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::read_notify_pipe"); // This is a (non-blocking) "speculative" read, i.e., we attempt to // read even if no event was polled on the read handle. A // speculative read is necessary since notifications must be // dispatched before IO events. We can avoid the speculative read // by "walking" the array of pollfd structures returned from // `/dev/poll' or `/dev/epoll' but that is potentially much more // expensive than simply checking for an EWOULDBLOCK. ssize_t n = ACE::recv (handle, (char *) &buffer, sizeof buffer); if (n > 0) { // Check to see if we've got a short read. if (n != sizeof buffer) { ssize_t remainder = sizeof buffer - n; // If so, try to recover by reading the remainder. If this // doesn't work we're in big trouble since the input stream // won't be aligned correctly. I'm not sure quite what to // do at this point. It's probably best just to return -1. if (ACE::recv (handle, ((char *) &buffer) + n, remainder) != remainder) return -1; } return 1; } // Return -1 if things have gone seriously wrong. if (n <= 0 && (errno != EWOULDBLOCK && errno != EAGAIN)) return -1; return n; }

---

Member Data Documentation

ACE_Dev_Poll_Reactor* ACE_Dev_Poll_Reactor_Notify::dp_reactor_ [protected]

Keep a back pointer to the ACE_Dev_Poll_Reactor. If this value if NULL then the ACE_Dev_Poll_Reactor has been initialized with disable_notify_pipe. Definition at line 257 of file Dev_Poll_Reactor.h. Referenced by notify, and open.

int ACE_Dev_Poll_Reactor_Notify::max_notify_iterations_ [protected]

Keeps track of the maximum number of times that the ACE_Dev_Poll_Reactor_Notify::handle_input method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify pipe before breaking out of its recv loop. By default, this is set to -1, which means "iterate until the pipe is empty." Definition at line 273 of file Dev_Poll_Reactor.h. Referenced by handle_input, and max_notify_iterations.

ACE_Pipe ACE_Dev_Poll_Reactor_Notify::notification_pipe_ [protected]

Contains the ACE_HANDLE the ACE_Dev_Poll_Reactor is listening on, as well as the ACE_HANDLE that threads wanting the attention of the ACE_Dev_Poll_Reactor will write to. Definition at line 264 of file Dev_Poll_Reactor.h. Referenced by close, dispatch_notifications, dump, notify_handle, and open.

---

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

• Dev_Poll_Reactor.h
• Dev_Poll_Reactor.cpp

---