ACE/ace/Metrics_Cache_T.inl

   1 // -*- C++ -*-
   2 #ifndef ACE_METRICS_CACHE_T_INL
   3 #define ACE_METRICS_CACHE_T_INL
   4
   5 #if defined (ACE_COMPILE_TIMEPROBES)
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 /////////////////////////////
  10 // Class ACE_Metrics_Cache //
  11 /////////////////////////////
  12
  13
  14 template <class ACE_LOCK, class ALLOCATOR>
  15 ACE_INLINE void
  16 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_enqueue_start (u_long i)
  17 {
  18   if (i < this->probe_set_size_)
  19     {
  20       u_long & count =
  21         this->enqueue_count_ [this->supplier_index_] [i];
  22       ++count;
  23
  24       if (! this->interval_initialized_)
  25         {
  26           this->interval_initialized_ = 1;
  27           ACE_hrtime_t hrtime_now = ACE_OS::gethrtime ();
  28           ACE_High_Res_Timer::hrtime_to_tv (this->interval_start_,
  29                                             hrtime_now);
  30           this->interval_end_.set (this->interval_start_.sec(),
  31                                    this->interval_start_.usec());
  32         }
  33
  34       // Take the metrics timeprobe last, to avoid measuring the above
  35       // metrics processing.
  36       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
  37         this->enqueue_probes_ [this->supplier_index_][i];
  38       probe->
  39         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_START);
  40     }
  41 }
  42
  43
  44 template <class ACE_LOCK, class ALLOCATOR>
  45 ACE_INLINE void
  46 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_enqueue_stop (u_long i)
  47 {
  48   if (i < this->probe_set_size_)
  49     {
  50       // Take the metrics timeprobe first, to avoid measuring the below
  51       // metrics processing.
  52       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
  53         this->enqueue_probes_ [this->supplier_index_][i];
  54       probe->
  55         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_STOP);
  56
  57       ACE_hrtime_t hrtime_now = ACE_OS::gethrtime ();
  58       ACE_High_Res_Timer::hrtime_to_tv (this->interval_end_,
  59                                             hrtime_now);
  60
  61       u_long & count = enqueue_count_ [this->supplier_index_][i];
  62       ++count;
  63     }
  64
  65 }
  66
  67
  68 template <class ACE_LOCK, class ALLOCATOR>
  69 ACE_INLINE void
  70 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_enqueue_suspend (u_long i)
  71 {
  72   if (i < this->probe_set_size_)
  73     {
  74       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
  75         this->enqueue_probes_ [this->supplier_index_][i];
  76       probe->
  77         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_SUSPEND);
  78       u_long & count =
  79         this->enqueue_count_ [this->supplier_index_] [i];
  80       ++count;
  81     }
  82 }
  83
  84
  85 template <class ACE_LOCK, class ALLOCATOR>
  86 ACE_INLINE void
  87 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_enqueue_resume (u_long i)
  88 {
  89   if (i < this->probe_set_size_)
  90     {
  91       u_long & count =
  92         this->enqueue_count_ [this->supplier_index_] [i];
  93       ++count;
  94       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
  95         this->enqueue_probes_ [this->supplier_index_][i];
  96       probe->
  97         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_RESUME);
  98     }
  99 }
 100
 101
 102 template <class ACE_LOCK, class ALLOCATOR>
 103 ACE_INLINE void
 104 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_dequeue_start (u_long i)
 105 {
 106   if (i < this->probe_set_size_)
 107     {
 108       u_long & count =
 109         this->dequeue_count_ [this->supplier_index_] [i];
 110       ++count;
 111
 112       if (! this->interval_initialized_)
 113         {
 114           this->interval_initialized_ = 1;
 115           ACE_hrtime_t hrtime_now = ACE_OS::gethrtime ();
 116           ACE_High_Res_Timer::hrtime_to_tv (this->interval_start_,
 117                                                     hrtime_now);
 118           this->interval_end_.set (this->interval_start_.sec(),
 119                                    this->interval_start_.usec());
 120         }
 121
 122       // Take the metrics timeprobe last, to avoid measuring the above
 123       // metrics processing.
 124       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
 125         this->dequeue_probes_ [this->supplier_index_][i];
 126       probe->
 127         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_START);
 128     }
 129 }
 130
 131
 132 template <class ACE_LOCK, class ALLOCATOR>
 133 ACE_INLINE void
 134 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_dequeue_stop (u_long i)
 135 {
 136   if (i < this->probe_set_size_)
 137     {
 138       // Take the metrics timeprobe first, to avoid measuring the
 139       // metrics processing below.
 140       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
 141         this->dequeue_probes_ [this->supplier_index_][i];
 142
 143       probe->timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_STOP);
 144
 145       ACE_hrtime_t hrtime_now = ACE_OS::gethrtime ();
 146       ACE_High_Res_Timer::hrtime_to_tv (this->interval_end_,
 147                                                     hrtime_now);
 148
 149       u_long & count = dequeue_count_ [this->supplier_index_] [i];
 150       ++count;
 151     }
 152 }
 153
 154
 155 template <class ACE_LOCK, class ALLOCATOR>
 156 ACE_INLINE void
 157 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_dequeue_suspend (u_long i)
 158 {
 159   if (i < this->probe_set_size_)
 160     {
 161       u_long & count =
 162         this->dequeue_count_ [this->supplier_index_] [i];
 163       ++count;
 164       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
 165         this->dequeue_probes_ [this->supplier_index_][i];
 166       probe->
 167         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_SUSPEND);
 168     }
 169 }
 170
 171
 172 template <class ACE_LOCK, class ALLOCATOR>
 173 ACE_INLINE void
 174 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::report_dequeue_resume (u_long i)
 175 {
 176   if (i < this->probe_set_size_)
 177     {
 178       u_long & count =
 179         this->dequeue_count_ [this->supplier_index_] [i];
 180       ++count;
 181       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
 182         this->dequeue_probes_ [this->supplier_index_][i];
 183       probe->
 184         timeprobe (ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::WORK_RESUME);
 185     }
 186 }
 187
 188
 189 template <class ACE_LOCK, class ALLOCATOR>
 190 ACE_INLINE void
 191 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::reset_base_statistics ()
 192 {
 193   this->interval_initialized_ = 0;
 194   this->interval_start_.set (0, 0);
 195   this->interval_end_.set (0, 0);
 196
 197   for (u_int i = 0; i < this->probe_set_size_; ++i)
 198     {
 199       this->enqueue_count_ [this->consumer_index_] [i] = 0;
 200       this->dequeue_count_ [this->consumer_index_] [i] = 0;
 201
 202       ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR> * probe =
 203         this->enqueue_probes_ [this->consumer_index_][i];
 204       probe->reset ();
 205       probe =
 206         this->dequeue_probes_ [this->consumer_index_][i];
 207       probe->reset ();
 208     }
 209 }
 210
 211
 212 // Flips the supplier and consumer positions.
 213
 214 template <class ACE_LOCK, class ALLOCATOR>
 215 ACE_INLINE void
 216 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::flip_supplier_and_consumer ()
 217 {
 218   int temp = consumer_index_;
 219   consumer_index_ = supplier_index_;
 220   supplier_index_ = temp;
 221 }
 222
 223 template <class ACE_LOCK, class ALLOCATOR>
 224 ACE_INLINE void
 225 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::metrics_enabled(int enabled)
 226 {
 227    metrics_enabled_ = enabled;
 228 }
 229
 230 template <class ACE_LOCK, class ALLOCATOR>
 231 ACE_INLINE int
 232 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::metrics_enabled() const
 233 {
 234    return metrics_enabled_;
 235 }
 236
 237 ACE_END_VERSIONED_NAMESPACE_DECL
 238
 239 #endif
 240
 241 #endif /* ACE_METRICS_CACHE_T_INL */