ACE/ace/Dynamic_Message_Strategy.cpp

   1 #include "ace/Dynamic_Message_Strategy.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 #include "ace/Dynamic_Message_Strategy.inl"
   5 #endif /* __ACE_INLINE__ */
   6
   7 #include "ace/Guard_T.h"
   8 #include "ace/Log_Category.h"
   9 #include "ace/Malloc_Base.h"
  10 #include "ace/OS_NS_string.h"
  11
  12 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  13
  14 // ctor
  15
  16 ACE_Dynamic_Message_Strategy::ACE_Dynamic_Message_Strategy (unsigned long static_bit_field_mask,
  17                                                             unsigned long static_bit_field_shift,
  18                                                             unsigned long dynamic_priority_max,
  19                                                             unsigned long dynamic_priority_offset)
  20   : static_bit_field_mask_ (static_bit_field_mask),
  21     static_bit_field_shift_ (static_bit_field_shift),
  22     dynamic_priority_max_ (dynamic_priority_max),
  23     dynamic_priority_offset_ (dynamic_priority_offset),
  24     max_late_ (0, dynamic_priority_offset - 1),
  25     min_pending_ (0, dynamic_priority_offset),
  26     pending_shift_ (0, dynamic_priority_max)
  27 {
  28 }
  29
  30 // dtor
  31
  32 ACE_Dynamic_Message_Strategy::~ACE_Dynamic_Message_Strategy (void)
  33 {
  34 }
  35
  36 ACE_Dynamic_Message_Strategy::Priority_Status
  37 ACE_Dynamic_Message_Strategy::priority_status (ACE_Message_Block & mb,
  38                                                const ACE_Time_Value & tv)
  39 {
  40   // default the message to have pending priority status
  41   Priority_Status status = ACE_Dynamic_Message_Strategy::PENDING;
  42
  43   // start with the passed absolute time as the message's priority, then
  44   // call the polymorphic hook method to (at least partially) convert
  45   // the absolute time and message attributes into the message's priority
  46   ACE_Time_Value priority (tv);
  47   convert_priority (priority, mb);
  48
  49   // if the priority is negative, the message is pending
  50   if (priority < ACE_Time_Value::zero)
  51     {
  52       // priority for pending messages must be shifted
  53       // upward above the late priority range
  54       priority += pending_shift_;
  55       if (priority < min_pending_)
  56         priority = min_pending_;
  57     }
  58   // otherwise, if the priority is greater than the maximum late
  59   // priority value that can be represented, it is beyond late
  60   else if (priority > max_late_)
  61     {
  62       // all messages that are beyond late are assigned lowest priority (zero)
  63       mb.msg_priority (0);
  64       return ACE_Dynamic_Message_Strategy::BEYOND_LATE;
  65     }
  66   // otherwise, the message is late, but its priority is correct
  67   else
  68     status = ACE_Dynamic_Message_Strategy::LATE;
  69
  70   // use (fast) bitwise operators to isolate and replace
  71   // the dynamic portion of the message's priority
  72   mb.msg_priority((mb.msg_priority() & static_bit_field_mask_) |
  73                   ((priority.usec () +
  74                     ACE_ONE_SECOND_IN_USECS * (suseconds_t)(priority.sec())) <<
  75                    static_bit_field_shift_));
  76
  77   // returns the priority status of the message
  78   return status;
  79 }
  80
  81
  82 // Dump the state of the strategy.
  83
  84 void
  85 ACE_Dynamic_Message_Strategy::dump (void) const
  86 {
  87 #if defined (ACE_HAS_DUMP)
  88   ACE_TRACE ("ACE_Dynamic_Message_Strategy::dump");
  89
  90   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  91
  92   ACELIB_DEBUG ((LM_DEBUG,
  93               ACE_TEXT ("static_bit_field_mask_ = %u\n")
  94               ACE_TEXT ("static_bit_field_shift_ = %u\n")
  95               ACE_TEXT ("dynamic_priority_max_ = %u\n")
  96               ACE_TEXT ("dynamic_priority_offset_ = %u\n")
  97               ACE_TEXT ("max_late_ = [%d sec, %d usec]\n")
  98               ACE_TEXT ("min_pending_ = [%d sec, %d usec]\n")
  99               ACE_TEXT ("pending_shift_ = [%d sec, %d usec]\n"),
 100               this->static_bit_field_mask_,
 101               this->static_bit_field_shift_,
 102               this->dynamic_priority_max_,
 103               this->dynamic_priority_offset_,
 104               this->max_late_.sec (),
 105               this->max_late_.usec (),
 106               this->min_pending_.sec (),
 107               this->min_pending_.usec (),
 108               this->pending_shift_.sec (),
 109               this->pending_shift_.usec ()));
 110
 111   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 112 #endif /* ACE_HAS_DUMP */
 113 }
 114
 115 ACE_Deadline_Message_Strategy::ACE_Deadline_Message_Strategy (unsigned long static_bit_field_mask,
 116                                                                unsigned long static_bit_field_shift,
 117                                                                unsigned long dynamic_priority_max,
 118                                                                unsigned long dynamic_priority_offset)
 119   : ACE_Dynamic_Message_Strategy (static_bit_field_mask,
 120                                   static_bit_field_shift,
 121                                   dynamic_priority_max,
 122                                   dynamic_priority_offset)
 123 {
 124 }
 125
 126 ACE_Deadline_Message_Strategy::~ACE_Deadline_Message_Strategy (void)
 127 {
 128 }
 129
 130 void
 131 ACE_Deadline_Message_Strategy::convert_priority (ACE_Time_Value & priority,
 132                                                  const ACE_Message_Block & mb)
 133 {
 134   // Convert absolute time passed in tv to negative time
 135   // to deadline of mb with respect to that absolute time.
 136   priority -= mb.msg_deadline_time ();
 137 }
 138   // dynamic priority conversion function based on time to deadline
 139
 140 void
 141 ACE_Deadline_Message_Strategy::dump (void) const
 142 {
 143 #if defined (ACE_HAS_DUMP)
 144   ACE_TRACE ("ACE_Deadline_Message_Strategy::dump");
 145
 146   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 147
 148   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Dynamic_Message_Strategy base class:\n")));
 149   this->ACE_Dynamic_Message_Strategy::dump ();
 150
 151   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nderived class: ACE_Deadline_Message_Strategy\n")));
 152
 153   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 154 #endif /* ACE_HAS_DUMP */
 155 }
 156
 157 ACE_Laxity_Message_Strategy::ACE_Laxity_Message_Strategy (unsigned long static_bit_field_mask,
 158                                                           unsigned long static_bit_field_shift,
 159                                                           unsigned long dynamic_priority_max,
 160                                                           unsigned long dynamic_priority_offset)
 161   : ACE_Dynamic_Message_Strategy (static_bit_field_mask,
 162                                   static_bit_field_shift,
 163                                   dynamic_priority_max,
 164                                   dynamic_priority_offset)
 165 {
 166 }
 167
 168 ACE_Laxity_Message_Strategy::~ACE_Laxity_Message_Strategy (void)
 169 {
 170 }
 171
 172 void
 173 ACE_Laxity_Message_Strategy::convert_priority (ACE_Time_Value & priority,
 174                                                const ACE_Message_Block & mb)
 175 {
 176   // Convert absolute time passed in tv to negative
 177   // laxity of mb with respect to that absolute time.
 178   priority += mb.msg_execution_time ();
 179   priority -= mb.msg_deadline_time ();
 180 }
 181   // dynamic priority conversion function based on laxity
 182
 183 void
 184 ACE_Laxity_Message_Strategy::dump (void) const
 185 {
 186 #if defined (ACE_HAS_DUMP)
 187   ACE_TRACE ("ACE_Laxity_Message_Strategy::dump");
 188
 189   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 190
 191   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Dynamic_Message_Strategy base class:\n")));
 192   this->ACE_Dynamic_Message_Strategy::dump ();
 193
 194   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nderived class: ACE_Laxity_Message_Strategy\n")));
 195
 196   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 197 #endif /* ACE_HAS_DUMP */
 198 }
 199   // Dump the state of the strategy.
 200
 201 ACE_END_VERSIONED_NAMESPACE_DECL