ACE/ace/Profile_Timer.cpp

   1 #include "ace/Profile_Timer.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 # include "ace/Profile_Timer.inl"
   5 #endif /* __ACE_INLINE__ */
   6
   7 #include "ace/Log_Category.h"
   8 #include "ace/OS_NS_string.h"
   9
  10 #if defined (ACE_HAS_GETRUSAGE) && !defined (ACE_WIN32)
  11
  12 #include "ace/OS_NS_stdio.h"
  13 #if defined (ACE_HAS_ALLOC_HOOKS)
  14 # include "ace/Malloc_Base.h"
  15 #endif /* ACE_HAS_ALLOC_HOOKS */
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 ACE_ALLOC_HOOK_DEFINE(ACE_Profile_Timer)
  20
  21 void
  22 ACE_Profile_Timer::dump () const
  23 {
  24 #if defined (ACE_HAS_DUMP)
  25   ACE_TRACE ("ACE_Profile_Timer::dump");
  26 #endif /* ACE_HAS_DUMP */
  27 }
  28
  29 // Initialize interval timer.
  30
  31 ACE_Profile_Timer::ACE_Profile_Timer ()
  32 {
  33   ACE_TRACE ("ACE_Profile_Timer::ACE_Profile_Timer");
  34   ACE_OS::memset (&this->end_usage_, 0, sizeof this->end_usage_);
  35   ACE_OS::memset (&this->begin_usage_, 0, sizeof this->begin_usage_);
  36   ACE_OS::memset (&this->last_usage_, 0, sizeof this->last_usage_);
  37
  38 #  if defined (ACE_HAS_GETRUSAGE)
  39   ACE_OS::memset (&this->begin_time_, 0, sizeof this->begin_time_);
  40   ACE_OS::memset (&this->end_time_, 0, sizeof this->end_time_);
  41   ACE_OS::memset (&this->last_time_, 0, sizeof this->last_time_);
  42 #  endif /* ACE_HAS_GETRUSAGE */
  43 }
  44
  45 // Terminate the interval timer.
  46 ACE_Profile_Timer::~ACE_Profile_Timer ()
  47 {
  48   ACE_TRACE ("ACE_Profile_Timer::~ACE_Profile_Timer");
  49 }
  50
  51 // Return the resource utilization.
  52
  53 void
  54 ACE_Profile_Timer::get_rusage (ACE_Profile_Timer::Rusage &usage)
  55 {
  56   ACE_TRACE ("ACE_Profile_Timer::get_rusage");
  57   usage = this->end_usage_;
  58 }
  59
  60 #  if defined (ACE_HAS_GETRUSAGE)
  61 // Compute the amount of resource utilization since the start time.
  62
  63 void
  64 ACE_Profile_Timer::elapsed_rusage (ACE_Profile_Timer::Rusage &usage)
  65 {
  66   ACE_TRACE ("ACE_Profile_Timer::elapsed_rusage");
  67   // integral shared memory size
  68   usage.ru_ixrss =
  69     this->end_usage_.ru_ixrss - this->last_usage_.ru_ixrss;
  70   // integral unshared data "
  71   usage.ru_idrss =
  72     this->end_usage_.ru_idrss - this->last_usage_.ru_idrss;
  73   // integral unshared stack "
  74   usage.ru_isrss =
  75     this->end_usage_.ru_isrss - this->last_usage_.ru_isrss;
  76   // page reclaims - total vmfaults
  77   usage.ru_minflt =
  78     this->end_usage_.ru_minflt - this->last_usage_.ru_minflt;
  79   // page faults
  80   usage.ru_majflt =
  81     this->end_usage_.ru_majflt - this->last_usage_.ru_majflt;
  82   // swaps
  83   usage.ru_nswap =
  84     this->end_usage_.ru_nswap - this->last_usage_.ru_nswap;
  85   // block input operations
  86   usage.ru_inblock =
  87     this->end_usage_.ru_inblock - this->last_usage_.ru_inblock;
  88   // block output operations
  89   usage.ru_oublock =
  90     this->end_usage_.ru_oublock - this->last_usage_.ru_oublock;
  91   // messages sent
  92   usage.ru_msgsnd =
  93     this->end_usage_.ru_msgsnd - this->last_usage_.ru_msgsnd;
  94   // messages received
  95   usage.ru_msgrcv =
  96     this->end_usage_.ru_msgrcv - this->last_usage_.ru_msgrcv;
  97   // signals received
  98   usage.ru_nsignals =
  99     this->end_usage_.ru_nsignals - this->last_usage_.ru_nsignals;
 100   // voluntary context switches
 101   usage.ru_nvcsw =
 102     this->end_usage_.ru_nvcsw - this->last_usage_.ru_nvcsw;
 103   // involuntary context switches
 104   usage.ru_nivcsw =
 105     this->end_usage_.ru_nivcsw - this->last_usage_.ru_nivcsw;
 106   this->subtract (usage.ru_utime,
 107                   this->end_usage_.ru_utime,
 108                   this->last_usage_.ru_utime);
 109   this->subtract (usage.ru_stime,
 110                   this->end_usage_.ru_stime,
 111                   this->last_usage_.ru_stime);
 112 }
 113
 114 void
 115 ACE_Profile_Timer::compute_times (ACE_Elapsed_Time &et)
 116 {
 117   ACE_TRACE ("ACE_Profile_Timer::compute_times");
 118
 119   timeval td;
 120
 121   this->subtract (td, this->end_time_, this->begin_time_);
 122   et.real_time = td.tv_sec + ((double) td.tv_usec) / ACE_ONE_SECOND_IN_USECS;
 123
 124   this->subtract (td, this->end_usage_.ru_utime, this->begin_usage_.ru_utime);
 125   et.user_time = td.tv_sec + ((double) td.tv_usec) / ACE_ONE_SECOND_IN_USECS;
 126
 127   this->subtract (td, this->end_usage_.ru_stime,  this->begin_usage_.ru_stime);
 128   et.system_time = td.tv_sec + ((double) td.tv_usec) / ACE_ONE_SECOND_IN_USECS;
 129 }
 130
 131 // Determine the difference between T1 and T2.
 132
 133 void
 134 ACE_Profile_Timer::subtract (timeval &tdiff, timeval &t1, timeval &t0)
 135 {
 136   ACE_TRACE ("ACE_Profile_Timer::subtract");
 137   tdiff.tv_sec  = t1.tv_sec - t0.tv_sec;
 138   tdiff.tv_usec = t1.tv_usec - t0.tv_usec;
 139
 140   // Normalize the time.
 141
 142   while (tdiff.tv_usec < 0)
 143     {
 144       tdiff.tv_sec--;
 145       tdiff.tv_usec += ACE_ONE_SECOND_IN_USECS;
 146     }
 147 }
 148
 149 #  endif /* ACE_HAS_GETRUSAGE */
 150
 151 // Compute the amount of time that has elapsed between start and stop.
 152
 153 int
 154 ACE_Profile_Timer::elapsed_time (ACE_Elapsed_Time &et)
 155 {
 156   ACE_TRACE ("ACE_Profile_Timer::elapsed_time");
 157   this->compute_times (et);
 158   return 0;
 159 }
 160
 161 ACE_END_VERSIONED_NAMESPACE_DECL
 162
 163 #elif defined (ACE_WIN32)
 164
 165 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 166
 167 void
 168 ACE_Profile_Timer::dump () const
 169 {
 170 #if defined (ACE_HAS_DUMP)
 171   ACE_TRACE ("ACE_Profile_Timer::dump");
 172   timer_.dump ();
 173 #endif /* ACE_HAS_DUMP */
 174 }
 175
 176 // Initialize interval timer.
 177 ACE_Profile_Timer::ACE_Profile_Timer ()
 178   : timer_ ()
 179 {
 180   ACE_TRACE ("ACE_Profile_Timer::ACE_Profile_Timer");
 181 #  if defined (ACE_HAS_GETRUSAGE)
 182
 183   ACE_OS::memset (&this->end_usage_, 0, sizeof this->end_usage_);
 184   ACE_OS::memset (&this->begin_usage_, 0, sizeof this->begin_usage_);
 185   ACE_OS::memset (&this->last_usage_, 0, sizeof this->last_usage_);
 186
 187   ACE_OS::memset (&this->begin_time_, 0, sizeof this->begin_time_);
 188   ACE_OS::memset (&this->end_time_, 0, sizeof this->end_time_);
 189   ACE_OS::memset (&this->last_time_, 0, sizeof this->last_time_);
 190 #  endif /* ACE_HAS_GETRUSAGE */
 191 }
 192
 193 int
 194 ACE_Profile_Timer::elapsed_time (ACE_Elapsed_Time &et)
 195 {
 196   ACE_TRACE ("ACE_Profile_Timer::elapsed_time");
 197
 198   ACE_hrtime_t delta_t; // nanoseconds
 199   timer_.elapsed_time (delta_t);
 200   et.real_time = (__int64) delta_t / (double) ACE_ONE_SECOND_IN_NSECS;
 201 #  if defined (ACE_HAS_GETRUSAGE)
 202   ACE_Time_Value atv = ACE_Time_Value (this->end_usage_.ru_utime)
 203                        - ACE_Time_Value (this->begin_usage_.ru_utime);
 204   et.user_time = atv.sec () + ((double) atv.usec ()) / ACE_ONE_SECOND_IN_USECS;
 205
 206   atv = ACE_Time_Value (this->end_usage_.ru_stime)
 207         - ACE_Time_Value (this->begin_usage_.ru_stime);
 208   et.system_time = atv.sec () + ((double) atv.usec ()) / ACE_ONE_SECOND_IN_USECS;
 209 #  else /* ACE_HAS_GETRUSAGE */
 210   et.user_time = 0;
 211   et.system_time = 0;
 212 #  endif /* ACE_HAS_GETRUSAGE */
 213
 214   return 0;
 215 }
 216
 217 // Return the resource utilization.
 218
 219 void
 220 ACE_Profile_Timer::get_rusage (ACE_Profile_Timer::Rusage &usage)
 221 {
 222   ACE_TRACE ("ACE_Profile_Timer::get_rusage");
 223 #  if defined (ACE_HAS_GETRUSAGE)
 224   usage = this->end_usage_;
 225 #  else /* ACE_HAS_GETRUSAGE */
 226   usage = 0;
 227 #  endif /* ACE_HAS_GETRUSAGE */
 228 }
 229
 230 // Compute the amount of resource utilization since the start time.
 231
 232 void
 233 ACE_Profile_Timer::elapsed_rusage (ACE_Profile_Timer::Rusage &usage)
 234 {
 235   ACE_TRACE ("ACE_Profile_Timer::elapsed_rusage");
 236
 237 #  if defined (ACE_HAS_GETRUSAGE)
 238   // Use ACE_Time_Value's as intermediate because the type of ru_utime can
 239   // be multiple types and using the - operator is not safe when this are
 240   // 64bit FILETIMEs on Windows
 241   ACE_Time_Value end_ru_utime (this->end_usage_.ru_utime);
 242   ACE_Time_Value begin_ru_utime (this->begin_usage_.ru_utime);
 243   usage.ru_utime = end_ru_utime - begin_ru_utime;
 244
 245   ACE_Time_Value end_ru_stime (this->end_usage_.ru_stime);
 246   ACE_Time_Value begin_ru_stime (this->begin_usage_.ru_stime);
 247   usage.ru_stime = end_ru_stime - begin_ru_stime;
 248 #  else /* ACE_HAS_GETRUSAGE */
 249   usage = 0;
 250 #  endif /* ACE_HAS_GETRUSAGE */
 251 }
 252
 253 #  if defined (ACE_HAS_GETRUSAGE)
 254 // Determine the difference between T1 and T2.
 255
 256 void
 257 ACE_Profile_Timer::subtract (timeval &tdiff, timeval &t1, timeval &t0)
 258 {
 259   ACE_TRACE ("ACE_Profile_Timer::subtract");
 260   tdiff.tv_sec  = t1.tv_sec - t0.tv_sec;
 261   tdiff.tv_usec = t1.tv_usec - t0.tv_usec;
 262
 263   // Normalize the time.
 264
 265   while (tdiff.tv_usec < 0)
 266     {
 267       tdiff.tv_sec--;
 268       tdiff.tv_usec += ACE_ONE_SECOND_IN_USECS;
 269     }
 270 }
 271 #  endif /* ACE_HAS_GETRUSAGE */
 272
 273 ACE_END_VERSIONED_NAMESPACE_DECL
 274
 275 #else
 276
 277 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 278
 279 void
 280 ACE_Profile_Timer::dump () const
 281 {
 282 #if defined (ACE_HAS_DUMP)
 283   ACE_TRACE ("ACE_Profile_Timer::dump");
 284   timer_.dump ();
 285 #endif /* ACE_HAS_DUMP */
 286 }
 287
 288 ACE_Profile_Timer::ACE_Profile_Timer ()
 289   : timer_ ()
 290 {
 291   ACE_TRACE ("ACE_Profile_Timer::ACE_Profile_Timer");
 292 }
 293
 294 int
 295 ACE_Profile_Timer::elapsed_time (ACE_Elapsed_Time &et)
 296 {
 297   ACE_TRACE ("ACE_Profile_Timer::elapsed_time");
 298
 299   ACE_hrtime_t delta_t; /* nanoseconds */
 300   timer_.elapsed_time (delta_t);
 301
 302   et.real_time = delta_t / (double) ACE_ONE_SECOND_IN_NSECS;
 303
 304   et.user_time = 0;
 305   et.system_time = 0;
 306
 307   return 0;
 308 }
 309
 310 void
 311 ACE_Profile_Timer::get_rusage (ACE_Profile_Timer::Rusage &usage)
 312 {
 313   ACE_TRACE ("ACE_Profile_Timer::get_rusage");
 314   usage = 0;
 315 }
 316
 317
 318 void
 319 ACE_Profile_Timer::elapsed_rusage (ACE_Profile_Timer::Rusage &usage)
 320 {
 321   ACE_TRACE ("ACE_Profile_Timer::elapsed_rusage");
 322   usage = 0;
 323 }
 324
 325 ACE_END_VERSIONED_NAMESPACE_DECL
 326
 327 #endif /* defined (ACE_HAS_GETRUSAGE) && !defined (ACE_WIN32) */