OpenDDS::DCPS::OfferedDeadlineWatchdog Class Reference

Watchdog responsible calling the DataWriterListener when the deadline period expires. More...

#include <OfferedDeadlineWatchdog.h>

Inheritance diagram for OpenDDS::DCPS::OfferedDeadlineWatchdog:
Inheritance graph
[legend]
Collaboration diagram for OpenDDS::DCPS::OfferedDeadlineWatchdog:
Collaboration graph
[legend]

List of all members.

Public Types

typedef ACE_Recursive_Thread_Mutex lock_type
typedef ACE_Reverse_Lock
< lock_type > 		reverse_lock_type

Public Member Functions

 OfferedDeadlineWatchdog (lock_type &lock, DDS::DeadlineQosPolicy qos, OpenDDS::DCPS::DataWriterImpl &writer_impl, DDS::OfferedDeadlineMissedStatus &status, CORBA::Long &last_total_count)
virtual ~OfferedDeadlineWatchdog ()
virtual int handle_timeout (const ACE_Time_Value &, const void *act)
void execute (DataWriterImpl &writer, PublicationInstance_rch instance, bool timer_called)
 Operation to be executed when the associated timer expires.
void schedule_timer (PublicationInstance_rch instance)
void cancel_timer (PublicationInstance_rch instance)
virtual void reschedule_deadline ()
 Re-schedule timer for all instances of the DataWriter.

Private Attributes

lock_type & status_lock_
 Lock for synchronization of status_ member.
reverse_lock_type reverse_status_lock_
 Reverse lock used for releasing the status_lock_ listener upcall.
WeakRcHandle< DataWriterImpl > writer_impl_
DDS::OfferedDeadlineMissedStatus & status_
CORBA::Long & last_total_count_
 Last total_count when status was last checked.

Detailed Description

Watchdog responsible calling the DataWriterListener when the deadline period expires.

This watchdog object calls the on_offered_deadline_missed() listener callback when the configured finite deadline period expires.

Definition at line 39 of file OfferedDeadlineWatchdog.h.

Member Typedef Documentation

typedef ACE_Recursive_Thread_Mutex OpenDDS::DCPS::OfferedDeadlineWatchdog::lock_type

Definition at line 42 of file OfferedDeadlineWatchdog.h.

typedef ACE_Reverse_Lock<lock_type> OpenDDS::DCPS::OfferedDeadlineWatchdog::reverse_lock_type

Definition at line 43 of file OfferedDeadlineWatchdog.h.

Constructor & Destructor Documentation

OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL OpenDDS::DCPS::OfferedDeadlineWatchdog::OfferedDeadlineWatchdog ( lock_type &  lock,
DDS::DeadlineQosPolicy  qos,
OpenDDS::DCPS::DataWriterImpl &  writer_impl,
DDS::OfferedDeadlineMissedStatus &  status,
CORBA::Long &  last_total_count 
)

Definition at line 17 of file OfferedDeadlineWatchdog.cpp.

00023   : Watchdog(duration_to_time_value(qos.period))
00024   , status_lock_(lock)
00025   , reverse_status_lock_(status_lock_)
00026   , writer_impl_(writer_impl)
00027   , status_(status)
00028   , last_total_count_(last_total_count)
00029 {
00030 }

OpenDDS::DCPS::OfferedDeadlineWatchdog::~OfferedDeadlineWatchdog (  )  [virtual]

Definition at line 32 of file OfferedDeadlineWatchdog.cpp.

00033 {
00034 }

Member Function Documentation

void OpenDDS::DCPS::OfferedDeadlineWatchdog::cancel_timer ( PublicationInstance_rch  instance  ) 

Definition at line 46 of file OfferedDeadlineWatchdog.cpp.

Referenced by execute().

00047 {
00048   if (instance->deadline_timer_id_ != -1) {
00049     Watchdog::cancel_timer(instance->deadline_timer_id_);
00050     instance->deadline_timer_id_ = -1;
00051   }
00052 }

Here is the caller graph for this function:

void OpenDDS::DCPS::OfferedDeadlineWatchdog::execute ( DataWriterImpl &  writer,
PublicationInstance_rch  instance,
bool  timer_called 
)

Operation to be executed when the associated timer expires.

This Watchdog object updates the DDS::OfferedDeadlineMissed structure, and calls DataWriterListener::on_requested_deadline_missed().

Definition at line 70 of file OfferedDeadlineWatchdog.cpp.

References cancel_timer(), ACE_OS::gettimeofday(), OpenDDS::DCPS::Watchdog::interval_, CORBA::is_nil(), DDS::OfferedDeadlineMissedStatus::last_instance_handle, last_total_count_, OpenDDS::DCPS::DataWriterImpl::listener_for(), OpenDDS::DCPS::EntityImpl::notify_status_condition(), DDS::OFFERED_DEADLINE_MISSED_STATUS, reverse_status_lock_, schedule_timer(), OpenDDS::DCPS::EntityImpl::set_status_changed_flag(), status, status_, status_lock_, DDS::OfferedDeadlineMissedStatus::total_count, DDS::OfferedDeadlineMissedStatus::total_count_change, and ACE_Time_Value::zero.

Referenced by handle_timeout().

00074 {
00075   if (instance->deadline_timer_id_ != -1) {
00076     bool missed = false;
00077 
00078     if (instance->cur_sample_tv_  == ACE_Time_Value::zero) { // not write any sample.
00079       missed = true;
00080 
00081     } else if (timer_called) { // handle_timeout is called
00082       ACE_Time_Value diff = ACE_OS::gettimeofday() - instance->cur_sample_tv_;
00083       missed = diff >= this->interval_;
00084 
00085     } else if (instance->last_sample_tv_ != ACE_Time_Value::zero) { // upon writing sample.
00086       ACE_Time_Value diff = instance->cur_sample_tv_ - instance->last_sample_tv_;
00087       missed = diff > this->interval_;
00088     }
00089 
00090     if (missed) {
00091       ACE_GUARD(ACE_Recursive_Thread_Mutex, monitor, this->status_lock_);
00092 
00093       if (timer_called) {
00094         ++this->status_.total_count;
00095         this->status_.total_count_change =
00096           this->status_.total_count - this->last_total_count_;
00097         this->status_.last_instance_handle = instance->instance_handle_;
00098 
00099         writer.set_status_changed_flag(
00100           DDS::OFFERED_DEADLINE_MISSED_STATUS, true);
00101 
00102         DDS::DataWriterListener_var listener =
00103           writer.listener_for(
00104             DDS::OFFERED_DEADLINE_MISSED_STATUS);
00105 
00106         if (! CORBA::is_nil(listener.in())) {
00107           // Copy before releasing the lock.
00108           DDS::OfferedDeadlineMissedStatus const status = this->status_;
00109 
00110           // Release the lock during the upcall.
00111           ACE_GUARD(reverse_lock_type, reverse_monitor, this->reverse_status_lock_);
00112 
00113           // @todo Will this operation ever throw?  If so we may want to
00114           //       catch all exceptions, and act accordingly.
00115           listener->on_offered_deadline_missed(&writer,
00116                                               status);
00117         }
00118 
00119         writer.notify_status_condition();
00120       }
00121     }
00122 
00123     // This next part is without status_lock_ held to avoid reactor deadlock.
00124     if (!timer_called) {
00125       this->cancel_timer(instance);
00126       this->schedule_timer(instance);
00127     }
00128 
00129   } else {
00130     // not an error - timer is scheduled asynchronously so we can get here
00131     // via WriteDataContainer::enqueue() before schedule_timer() is done
00132   }
00133 }

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::DCPS::OfferedDeadlineWatchdog::handle_timeout ( const ACE_Time_Value &  ,
const void *  act 
) [virtual]

Reimplemented from ACE_Event_Handler.

Definition at line 55 of file OfferedDeadlineWatchdog.cpp.

References execute(), OpenDDS::DCPS::WeakRcHandle< T >::lock(), and writer_impl_.

00056 {
00057   DDS::InstanceHandle_t handle = static_cast<DDS::InstanceHandle_t>(reinterpret_cast<intptr_t>(act));
00058   RcHandle<DataWriterImpl> writer = writer_impl_.lock();
00059   if (writer) {
00060     OpenDDS::DCPS::PublicationInstance_rch instance =
00061       writer->get_handle_instance(handle);
00062     if (instance)
00063       execute(*writer, instance, true);
00064   }
00065   return 0;
00066 }

Here is the call graph for this function:

void OpenDDS::DCPS::OfferedDeadlineWatchdog::reschedule_deadline (  )  [virtual]

Re-schedule timer for all instances of the DataWriter.

Implements OpenDDS::DCPS::Watchdog.

Definition at line 136 of file OfferedDeadlineWatchdog.cpp.

References OpenDDS::DCPS::WeakRcHandle< T >::lock(), and writer_impl_.

00137 {
00138   RcHandle<DataWriterImpl> writer = writer_impl_.lock();
00139   if (writer)
00140     writer->reschedule_deadline();
00141 }

Here is the call graph for this function:

void OpenDDS::DCPS::OfferedDeadlineWatchdog::schedule_timer ( PublicationInstance_rch  instance  ) 

Definition at line 37 of file OfferedDeadlineWatchdog.cpp.

References OpenDDS::DCPS::Watchdog::interval_.

Referenced by execute().

00038 {
00039   if (instance->deadline_timer_id_ == -1) {
00040     intptr_t handle = instance->instance_handle_;
00041     instance->deadline_timer_id_ = Watchdog::schedule_timer(reinterpret_cast<const void*>(handle), this->interval_);
00042   }
00043 }

Here is the caller graph for this function:

Member Data Documentation

CORBA::Long& OpenDDS::DCPS::OfferedDeadlineWatchdog::last_total_count_ [private]

Last total_count when status was last checked.

Definition at line 91 of file OfferedDeadlineWatchdog.h.

Referenced by execute().

reverse_lock_type OpenDDS::DCPS::OfferedDeadlineWatchdog::reverse_status_lock_ [private]

Reverse lock used for releasing the status_lock_ listener upcall.

Definition at line 80 of file OfferedDeadlineWatchdog.h.

Referenced by execute().

DDS::OfferedDeadlineMissedStatus& OpenDDS::DCPS::OfferedDeadlineWatchdog::status_ [private]

Reference to the missed requested deadline status structure.

Definition at line 88 of file OfferedDeadlineWatchdog.h.

Referenced by execute().

lock_type& OpenDDS::DCPS::OfferedDeadlineWatchdog::status_lock_ [private]

Lock for synchronization of status_ member.

Definition at line 78 of file OfferedDeadlineWatchdog.h.

Referenced by execute().

WeakRcHandle<DataWriterImpl> OpenDDS::DCPS::OfferedDeadlineWatchdog::writer_impl_ [private]

Pointer to the DataWriterImpl object from which the DataWriterListener is obtained.

Definition at line 84 of file OfferedDeadlineWatchdog.h.

Referenced by handle_timeout(), and reschedule_deadline().

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on 10 Aug 2018 for OpenDDS by  doxygen 1.6.1