ACE_WFMO_Reactor_Notify Class Reference

Unblock the from its event loop, passing it an optional ACE_Event_Handler to dispatch. More...

#include <WFMO_Reactor.h>

Inheritance diagram for ACE_WFMO_Reactor_Notify:

[legend]Collaboration diagram for ACE_WFMO_Reactor_Notify:

[legend]List of all members.

Public Member Functions
	ACE_WFMO_Reactor_Notify (size_t max_notifies=1024)
	Constructor.
virtual int	open (ACE_Reactor_Impl *wfmo_reactor, ACE_Timer_Queue *timer_queue, int disable_notify=0)
	Initialization. is stored to call .
virtual int	close (void)
	No-op.
virtual int	notify (ACE_Event_Handler *event_handler=0, ACE_Reactor_Mask mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *timeout=0)
virtual int	dispatch_notifications (int &number_of_active_handles, ACE_Handle_Set &rd_mask)
	No-op.
virtual ACE_HANDLE	get_handle (void) const
	Returns a handle to the .
virtual ACE_HANDLE	notify_handle (void)
virtual int	dispatch_notify (ACE_Notification_Buffer &buffer)
virtual int	is_dispatchable (ACE_Notification_Buffer &buffer)
	Verify whether the buffer has dispatchable info or not.
virtual int	read_notify_pipe (ACE_HANDLE handle, ACE_Notification_Buffer &buffer)
void	max_notify_iterations (int)
int	max_notify_iterations (void)
virtual int	purge_pending_notifications (ACE_Event_Handler *, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual void	dump (void) const
	Dump the state of an object.
Private Member Functions
virtual int	handle_signal (int signum, siginfo_t *=0, ucontext_t *=0)
Private Attributes
ACE_Timer_Queue *	timer_queue_
	Pointer to the wfmo_reactor's timer queue.
ACE_Auto_Event	wakeup_one_thread_
ACE_Message_Queue< ACE_MT_SYNCH >	message_queue_
int	max_notify_iterations_

---

Detailed Description

Unblock the from its event loop, passing it an optional ACE_Event_Handler to dispatch.

This implementation is necessary for cases where the is run in a multi-threaded program. In this case, we need to be able to unblock when updates occur other than in the main thread. To do this, we signal an auto-reset event the is listening on. If an ACE_Event_Handler and is passed to , the appropriate <handle_*> method is dispatched.

Definition at line 495 of file WFMO_Reactor.h.

---

Constructor & Destructor Documentation

ACE_WFMO_Reactor_Notify::ACE_WFMO_Reactor_Notify (  size_t  max_notifies = 1024  )

Constructor. Definition at line 2341 of file WFMO_Reactor.cpp. : timer_queue_ (0), message_queue_ (max_notifies * sizeof (ACE_Notification_Buffer), max_notifies * sizeof (ACE_Notification_Buffer)), max_notify_iterations_ (-1) { }

---

Member Function Documentation

int ACE_WFMO_Reactor_Notify::close (  void   )  [virtual]

No-op. Implements ACE_Reactor_Notify. Definition at line 2336 of file WFMO_Reactor.cpp. { return -1; }

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

No-op. Implements ACE_Reactor_Notify. Definition at line 2304 of file WFMO_Reactor.cpp. { return -1; }

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

Handle one of the notify call on the . This could be because of a thread trying to unblock the Implements ACE_Reactor_Notify. Definition at line 2330 of file WFMO_Reactor.cpp. { return 0; }

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

Dump the state of an object. Implements ACE_Reactor_Notify. Definition at line 2631 of file WFMO_Reactor.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dump(), and LM_DEBUG. { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_WFMO_Reactor_Notify::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); this->timer_queue_->dump (); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Max. iteration: %d\n"), this->max_notify_iterations_)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

ACE_HANDLE ACE_WFMO_Reactor_Notify::get_handle (  void   )  const [virtual]

Returns a handle to the . Reimplemented from ACE_Event_Handler. Definition at line 2360 of file WFMO_Reactor.cpp. References ACE_Event::handle(), and wakeup_one_thread_. { return this->wakeup_one_thread_.handle (); }

int ACE_WFMO_Reactor_Notify::handle_signal (  int  signum, siginfo_t *  = 0, ucontext_t *  = 0 )  [private, virtual]

Called when the notification event waited on by is signaled. This dequeues all pending and dispatches them. Reimplemented from ACE_Event_Handler. Definition at line 2368 of file WFMO_Reactor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_Message_Block::base(), ACE_Message_Queue< ACE_MT_SYNCH >::dequeue_head(), ACE_Notification_Buffer::eh_, EWOULDBLOCK, ACE_Event::handle(), 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(), ACE_Message_Queue< ACE_MT_SYNCH >::is_empty(), LM_ERROR, ACE_Notification_Buffer::mask_, ACE_Event_Handler::reference_counting_policy(), ACE_Message_Block::release(), ACE_Event_Handler::remove_reference(), siginfo_t::si_handle_, ACE_Event::signal(), ucontext_t, and wakeup_one_thread_. { ACE_UNUSED_ARG (signum); // Just check for sanity... if (siginfo->si_handle_ != this->wakeup_one_thread_.handle ()) return -1; // This will get called when <WFMO_Reactor->wakeup_one_thread_> event // is signaled. // ACE_DEBUG ((LM_DEBUG, // ACE_LIB_TEXT ("(%t) waking up to handle internal notifications\n"))); for (int i = 1; ; ++i) { ACE_Message_Block *mb = 0; // Copy ACE_Time_Value::zero since dequeue_head will modify it. ACE_Time_Value zero_timeout (ACE_Time_Value::zero); if (this->message_queue_.dequeue_head (mb, &zero_timeout) == -1) { if (errno == EWOULDBLOCK) // We've reached the end of the processing, return // normally. return 0; else return -1; // Something weird happened... } else { ACE_Notification_Buffer *buffer = reinterpret_cast <ACE_Notification_Buffer *> (mb->base ()); // If eh == 0 then we've got major problems! Otherwise, we // need to dispatch the appropriate handle_* method on the // ACE_Event_Handler pointer we've been passed. if (buffer->eh_ != 0) { ACE_Event_Handler *event_handler = buffer->eh_; int requires_reference_counting = event_handler->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; int result = 0; switch (buffer->mask_) { case ACE_Event_Handler::READ_MASK: case ACE_Event_Handler::ACCEPT_MASK: result = event_handler->handle_input (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::WRITE_MASK: result = event_handler->handle_output (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::EXCEPT_MASK: result = event_handler->handle_exception (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::QOS_MASK: result = event_handler->handle_qos (ACE_INVALID_HANDLE); break; case ACE_Event_Handler::GROUP_QOS_MASK: result = event_handler->handle_group_qos (ACE_INVALID_HANDLE); break; default: ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("invalid mask = %d\n"), buffer->mask_)); break; } if (result == -1) event_handler->handle_close (ACE_INVALID_HANDLE, ACE_Event_Handler::EXCEPT_MASK); if (requires_reference_counting) { event_handler->remove_reference (); } } // Make sure to delete the memory regardless of success or // failure! mb->release (); // Bail out if we've reached the <max_notify_iterations_>. // Note that by default <max_notify_iterations_> is -1, so // we'll loop until we're done. if (i == this->max_notify_iterations_) { // If there are still notification in the queue, we need // to wake up again if (!this->message_queue_.is_empty ()) this->wakeup_one_thread_.signal (); // Break the loop as we have reached max_notify_iterations_ return 0; } } } }

int ACE_WFMO_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 2311 of file WFMO_Reactor.cpp. { return 0; }

int ACE_WFMO_Reactor_Notify::max_notify_iterations (  void   )  [virtual]

Get the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method 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_Notify. Definition at line 2525 of file WFMO_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_WFMO_Reactor_Notify::max_notify_iterations"); return this->max_notify_iterations_; }

void ACE_WFMO_Reactor_Notify::max_notify_iterations (  int   )  [virtual]

Set the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method 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_Notify. Definition at line 2514 of file WFMO_Reactor.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_WFMO_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; }

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

Special trick to unblock when updates occur. All we do is enqueue and onto the ACE_Message_Queue and wakeup the by signaling its handle. The indicates how long to blocking trying to notify the . If == 0, the caller will block until action is possible, else will wait until the relative time specified in elapses). Implements ACE_Reactor_Notify. Definition at line 2478 of file WFMO_Reactor.cpp. References ACE_NEW_RETURN, ACE_Reactor_Mask, ACE_Event_Handler::add_reference(), ACE_Message_Block::base(), ACE_Notification_Buffer::eh_, ACE_Message_Queue< ACE_MT_SYNCH >::enqueue_tail(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday(), ACE_Notification_Buffer::mask_, ACE_Message_Block::release(), ACE_Event::signal(), and wakeup_one_thread_. { if (event_handler != 0) { ACE_Message_Block *mb = 0; ACE_NEW_RETURN (mb, ACE_Message_Block (sizeof (ACE_Notification_Buffer)), -1); ACE_Notification_Buffer *buffer = (ACE_Notification_Buffer *) mb->base (); buffer->eh_ = event_handler; buffer->mask_ = mask; // Convert from relative time to absolute time by adding the // current time of day. This is what <ACE_Message_Queue> // expects. if (timeout != 0) *timeout += timer_queue_->gettimeofday (); if (this->message_queue_.enqueue_tail (mb, timeout) == -1) { mb->release (); return -1; } event_handler->add_reference (); } return this->wakeup_one_thread_.signal (); }

ACE_HANDLE ACE_WFMO_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 Implements ACE_Reactor_Notify. Definition at line 2317 of file WFMO_Reactor.cpp. { return ACE_INVALID_HANDLE; }

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

Initialization. is stored to call . Implements ACE_Reactor_Notify. Definition at line 2350 of file WFMO_Reactor.cpp. References ACE_Timer_Queue, and ACE_Reactor_Impl::register_handler(). { ACE_UNUSED_ARG (ignore_notify); timer_queue_ = timer_queue; return wfmo_reactor->register_handler (this); }

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

Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. If == 0, all notifications for all handlers are removed (but not any notifications posted just to wake up the reactor itself). Returns the number of notifications purged. Returns -1 on error. Implements ACE_Reactor_Notify. Definition at line 2532 of file WFMO_Reactor.cpp. References ACE_ASSERT, ACE_BIT_DISABLED, ACE_CLR_BITS, ACE_GUARD_RETURN, ACE_Reactor_Mask, ACE_SYNCH_MUTEX, ACE_TRACE, ACE_Message_Block::base(), ACE_Message_Queue<>::dequeue_head(), ACE_Message_Queue< ACE_MT_SYNCH >::dequeue_head(), ACE_Notification_Buffer::eh_, ACE_Message_Queue< ACE_MT_SYNCH >::enqueue_head(), ACE_Message_Queue<>::enqueue_head(), ACE_Message_Queue< ACE_MT_SYNCH >::is_empty(), ACE_Notification_Buffer::mask_, ACE_Message_Queue<>::message_count(), ACE_Message_Queue< ACE_MT_SYNCH >::message_count(), ACE_Message_Block::release(), and ACE_Event_Handler::remove_reference(). { ACE_TRACE ("ACE_WFMO_Reactor_Notify::purge_pending_notifications"); // Go over message queue and take out all the matching event // handlers. If eh == 0, purge all. Note that reactor notifies (no // handler specified) are never purged, as this may lose a needed // notify the reactor queued for itself. if (this->message_queue_.is_empty ()) return 0; // Guard against new and/or delivered notifications while purging. // WARNING!!! The use of the notification queue's lock object for // this guard makes use of the knowledge that on Win32, the mutex // protecting the queue is really a CriticalSection, which is // recursive. This is how we can get away with locking it down here // and still calling member functions on the queue object. ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, monitor, this->message_queue_.lock(), -1); // first, copy all to our own local queue. Since we've locked everyone out // of here, there's no need to use any synchronization on this queue. ACE_Message_Queue<ACE_NULL_SYNCH> local_queue; size_t queue_size = this->message_queue_.message_count (); int number_purged = 0; size_t index; for (index = 0; index < queue_size; ++index) { ACE_Message_Block *mb = 0; if (-1 == this->message_queue_.dequeue_head (mb)) return -1; // This shouldn't happen... ACE_Notification_Buffer *buffer = reinterpret_cast<ACE_Notification_Buffer *> (mb->base ()); // 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 != buffer->eh_) && (0 == eh || eh == buffer->eh_) && ACE_BIT_DISABLED (buffer->mask_, ~mask)) // the existing notification mask // is left with nothing when // applying the mask { ACE_Event_Handler *event_handler = buffer->eh_; event_handler->remove_reference (); mb->release (); ++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 // particularhandler), and it matches the specified handler // (or purging all), then apply the mask if ((0 != buffer->eh_) && (0 == eh || eh == buffer->eh_)) ACE_CLR_BITS(buffer->mask_, mask); if (-1 == local_queue.enqueue_head (mb)) return -1; } } if (this->message_queue_.message_count ()) { // Should be empty! ACE_ASSERT (0); return -1; } // Now copy back from the local queue to the class queue, taking // care to preserve the original order... queue_size = local_queue.message_count (); for (index = 0; index < queue_size; ++index) { ACE_Message_Block *mb = 0; if (-1 == local_queue.dequeue_head (mb)) { ACE_ASSERT (0); return -1; } if (-1 == this->message_queue_.enqueue_head (mb)) { ACE_ASSERT (0); return -1; } } return number_purged; }

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

Read one of the notify call on the into the . This could be because of a thread trying to unblock the Implements ACE_Reactor_Notify. Definition at line 2323 of file WFMO_Reactor.cpp. { return 0; }

---

Member Data Documentation

int ACE_WFMO_Reactor_Notify::max_notify_iterations_ [private]

Keeps track of the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method 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." Definition at line 610 of file WFMO_Reactor.h.

ACE_Message_Queue<ACE_MT_SYNCH> ACE_WFMO_Reactor_Notify::message_queue_ [private]

Message queue that keeps track of pending . This queue must be thread-safe because it can be called by multiple threads of control. Definition at line 600 of file WFMO_Reactor.h.

ACE_Timer_Queue* ACE_WFMO_Reactor_Notify::timer_queue_ [private]

Pointer to the wfmo_reactor's timer queue. Definition at line 584 of file WFMO_Reactor.h.

ACE_Auto_Event ACE_WFMO_Reactor_Notify::wakeup_one_thread_ [private]

An auto event is used so that we can it to wakeup one thread up (e.g., when the method is called). Definition at line 595 of file WFMO_Reactor.h. Referenced by get_handle(), handle_signal(), and notify().

---

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

• WFMO_Reactor.h
• WFMO_Reactor.cpp

---