ACE/ace/Time_Value.cpp

   1 #include "ace/Time_Value.h"
   2
   3 #if defined (ACE_HAS_ALLOC_HOOKS)
   4 # include "ace/Malloc_Base.h"
   5 #endif /* ACE_HAS_ALLOC_HOOKS */
   6
   7 #if !defined (__ACE_INLINE__)
   8 #include "ace/Time_Value.inl"
   9 #endif /* __ACE_INLINE__ */
  10
  11 #include "ace/Numeric_Limits.h"
  12 #include "ace/If_Then_Else.h"
  13 #include "ace/OS_NS_math.h"
  14 #include "ace/Time_Policy.h"
  15 #include <iomanip>
  16 #include <cstdlib>
  17 #include <cmath>
  18
  19 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  20
  21 /// Static constant representing `zero-time'.
  22 /// Note: this object requires static construction.
  23 const ACE_Time_Value ACE_Time_Value::zero;
  24
  25 /// Constant for maximum time representable.  Note that this time
  26 /// is not intended for use with select () or other calls that may
  27 /// have *their own* implementation-specific maximum time representations.
  28 /// Its primary use is in time computations such as those used by the
  29 /// dynamic subpriority strategies in the ACE_Dynamic_Message_Queue class.
  30 /// Note: this object requires static construction.
  31 const ACE_Time_Value ACE_Time_Value::max_time (
  32   ACE_Numeric_Limits<time_t>::max (),
  33   ACE_ONE_SECOND_IN_USECS - 1);
  34
  35 ACE_ALLOC_HOOK_DEFINE (ACE_Time_Value)
  36
  37 /// Increment microseconds (the only reason this is here is to allow
  38 /// the use of ACE_Atomic_Op with ACE_Time_Value).
  39 ACE_Time_Value
  40 ACE_Time_Value::operator ++ (int)
  41 {
  42   // ACE_OS_TRACE ("ACE_Time_Value::operator ++ (int)");
  43   ACE_Time_Value tv (*this);
  44   ++*this;
  45   return tv;
  46 }
  47
  48 ACE_Time_Value &
  49 ACE_Time_Value::operator ++ ()
  50 {
  51   // ACE_OS_TRACE ("ACE_Time_Value::operator ++ ()");
  52   this->usec (this->usec () + 1);
  53   this->normalize ();
  54   return *this;
  55 }
  56
  57 /// Decrement microseconds (the only reason this is here is / to allow
  58 /// the use of ACE_Atomic_Op with ACE_Time_Value).
  59 ACE_Time_Value
  60 ACE_Time_Value::operator -- (int)
  61 {
  62   // ACE_OS_TRACE ("ACE_Time_Value::operator -- (int)");
  63   ACE_Time_Value tv (*this);
  64   --*this;
  65   return tv;
  66 }
  67
  68 ACE_Time_Value &
  69 ACE_Time_Value::operator -- ()
  70 {
  71   // ACE_OS_TRACE ("ACE_Time_Value::operator -- ()");
  72   this->usec (this->usec () - 1);
  73   this->normalize ();
  74   return *this;
  75 }
  76
  77 #if defined (ACE_WIN32)
  78 /// Static constant to remove time skew between FILETIME and POSIX
  79 /// time.  POSIX and Win32 use different epochs (Jan. 1, 1970 v.s.
  80 /// Jan. 1, 1601).  The following constant defines the difference
  81 /// in 100ns ticks.
  82 ///
  83 /// In the beginning (Jan. 1, 1601), there was no time and no computer.
  84 /// And Bill said: "Let there be time," and there was time....
  85 const DWORDLONG ACE_Time_Value::FILETIME_to_timval_skew =
  86 ACE_INT64_LITERAL (0x19db1ded53e8000);
  87
  88 ///  Initializes the ACE_Time_Value object from a Win32 FILETIME
  89 ACE_Time_Value::ACE_Time_Value (const FILETIME &file_time)
  90 {
  91   // // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value");
  92   this->set (file_time);
  93 }
  94
  95 void ACE_Time_Value::set (const FILETIME &file_time)
  96 {
  97   // Initializes the ACE_Time_Value object from a Win32 FILETIME
  98   // Don't use a struct initializer, gcc don't like it.
  99   ULARGE_INTEGER _100ns;
 100   _100ns.LowPart = file_time.dwLowDateTime;
 101   _100ns.HighPart = file_time.dwHighDateTime;
 102
 103   _100ns.QuadPart -= ACE_Time_Value::FILETIME_to_timval_skew;
 104
 105   // Convert 100ns units to seconds;
 106   this->tv_.tv_sec = (time_t) (_100ns.QuadPart / (10000 * 1000));
 107   // Convert remainder to microseconds;
 108   this->tv_.tv_usec = (suseconds_t) ((_100ns.QuadPart % (10000 * 1000)) / 10);
 109
 110   this->normalize ();
 111 }
 112
 113 /// Returns the value of the object as a Win32 FILETIME.
 114 ACE_Time_Value::operator FILETIME () const
 115 {
 116   FILETIME file_time;
 117   // ACE_OS_TRACE ("ACE_Time_Value::operator FILETIME");
 118
 119   ULARGE_INTEGER _100ns;
 120   _100ns.QuadPart = (((DWORDLONG) this->tv_.tv_sec * (10000 * 1000) +
 121                      this->tv_.tv_usec * 10) +
 122                      ACE_Time_Value::FILETIME_to_timval_skew);
 123
 124   file_time.dwLowDateTime = _100ns.LowPart;
 125   file_time.dwHighDateTime = _100ns.HighPart;
 126
 127   return file_time;
 128 }
 129 #endif /* ACE_WIN32 */
 130
 131 ACE_Time_Value
 132 ACE_Time_Value::now () const
 133 {
 134   ACE_System_Time_Policy systp;
 135   return systp ();
 136 }
 137
 138 ACE_Time_Value
 139 ACE_Time_Value::to_relative_time () const
 140 {
 141   ACE_System_Time_Policy systp;
 142   return (*this) - systp ();
 143 }
 144
 145 ACE_Time_Value
 146 ACE_Time_Value::to_absolute_time () const
 147 {
 148   ACE_System_Time_Policy systp;
 149   return (*this) + systp ();
 150 }
 151
 152 ACE_Time_Value *
 153 ACE_Time_Value::duplicate () const
 154 {
 155   ACE_Time_Value * tmp = 0;
 156   ACE_NEW_RETURN (tmp, ACE_Time_Value (*this), 0);
 157   return tmp;
 158 }
 159
 160 void
 161 ACE_Time_Value::dump () const
 162 {
 163 }
 164
 165 void
 166 ACE_Time_Value::normalize (bool saturate)
 167 {
 168   // ACE_OS_TRACE ("ACE_Time_Value::normalize");
 169   if (this->tv_.tv_usec >= ACE_ONE_SECOND_IN_USECS ||
 170       this->tv_.tv_usec <= -ACE_ONE_SECOND_IN_USECS)
 171     {
 172       time_t const sec = std::abs(this->tv_.tv_usec) / ACE_ONE_SECOND_IN_USECS * (this->tv_.tv_usec > 0 ? 1 : -1);
 173       suseconds_t const usec = static_cast<suseconds_t> (this->tv_.tv_usec - sec * ACE_ONE_SECOND_IN_USECS);
 174
 175       if (saturate && this->tv_.tv_sec > 0 && sec > 0 &&
 176           ACE_Numeric_Limits<time_t>::max() - this->tv_.tv_sec < sec)
 177         {
 178           this->tv_.tv_sec = ACE_Numeric_Limits<time_t>::max();
 179           this->tv_.tv_usec = ACE_ONE_SECOND_IN_USECS - 1;
 180         }
 181       else if (saturate && this->tv_.tv_sec < 0 && sec < 0 &&
 182                ACE_Numeric_Limits<time_t>::min() - this->tv_.tv_sec > sec)
 183         {
 184           this->tv_.tv_sec = ACE_Numeric_Limits<time_t>::min();
 185           this->tv_.tv_usec = -ACE_ONE_SECOND_IN_USECS + 1;
 186         }
 187       else
 188         {
 189           this->tv_.tv_sec += sec;
 190           this->tv_.tv_usec = usec;
 191         }
 192     }
 193
 194   if (this->tv_.tv_sec >= 1 && this->tv_.tv_usec < 0)
 195     {
 196       --this->tv_.tv_sec;
 197       this->tv_.tv_usec += ACE_ONE_SECOND_IN_USECS;
 198     }
 199   // tv_sec in qnxnto is unsigned
 200 #if !defined ( __QNX__)
 201   else if (this->tv_.tv_sec < 0 && this->tv_.tv_usec > 0)
 202     {
 203       ++this->tv_.tv_sec;
 204       this->tv_.tv_usec -= ACE_ONE_SECOND_IN_USECS;
 205     }
 206 #endif /* __QNX__  */
 207 }
 208
 209
 210 ACE_Time_Value &
 211 ACE_Time_Value::operator *= (double d)
 212 {
 213   // To work around the lack of precision of a long double to contain
 214   // a 64-bits time_t + 6 digits after the decimal point for the usec part,
 215   // we perform the multiplication of the 2 timeval parts separately.
 216   //
 217   // This extra precision step is adding a cost when transfering the
 218   // seconds resulting from the usec multiplication.  This operation
 219   // correspond to the normalization process performed in normalize()
 220   // but we must absolutly do it here because the usec multiplication
 221   // result value could exceed what can be stored in a suseconds_t
 222   // type variable.
 223   //
 224   // Since this is a costly operation, we try to detect as soon as
 225   // possible if we are having a saturation in order to abort the rest
 226   // of the computation.
 227   using float_type = ACE::If_Then_Else<(sizeof(double) > sizeof(time_t)), double, long double>::result_type;
 228
 229   float_type sec_total = static_cast<float_type> (this->sec());
 230   sec_total *= d;
 231
 232   // shall we saturate the result?
 233   static const float_type max_int =
 234     ACE_Numeric_Limits<time_t>::max() + 0.999999;
 235   static const float_type min_int =
 236     ACE_Numeric_Limits<time_t>::min() - 0.999999;
 237
 238   if (sec_total > max_int)
 239     {
 240       this->set(ACE_Numeric_Limits<time_t>::max(), ACE_ONE_SECOND_IN_USECS-1);
 241     }
 242   else if (sec_total < min_int)
 243     {
 244       this->set(ACE_Numeric_Limits<time_t>::min(), -ACE_ONE_SECOND_IN_USECS+1);
 245     }
 246   else
 247     {
 248       time_t time_sec = static_cast<time_t> (sec_total);
 249
 250       float_type usec_total = this->usec();
 251       usec_total *= d;
 252
 253       // adding usec resulting from tv_sec mult
 254       usec_total += (sec_total-time_sec) * ACE_ONE_SECOND_IN_USECS;
 255
 256       // extract seconds component of the usec mult
 257       sec_total = usec_total / ACE_ONE_SECOND_IN_USECS;
 258       // keep remaining usec
 259       if (sec_total > 0)
 260         {
 261           usec_total = (sec_total - ACE_OS::floor(sec_total));
 262         }
 263       else
 264         {
 265           usec_total = (sec_total - ACE_OS::ceil(sec_total));
 266         }
 267
 268       sec_total -= usec_total;
 269       usec_total *= ACE_ONE_SECOND_IN_USECS;
 270
 271       // add the seconds component of the usec mult with the tv_sec mult prod.
 272       sec_total += time_sec;
 273
 274       // recheck for saturation
 275       if (sec_total > max_int)
 276         {
 277           this->set (ACE_Numeric_Limits<time_t>::max(), ACE_ONE_SECOND_IN_USECS - 1);
 278         }
 279       else if (sec_total < min_int)
 280         {
 281           this->set (ACE_Numeric_Limits<time_t>::min(), -ACE_ONE_SECOND_IN_USECS + 1);
 282         }
 283       else
 284         {
 285           time_sec = static_cast<time_t> (sec_total);
 286           suseconds_t time_usec = static_cast<suseconds_t> (usec_total);
 287
 288           // round up the result to save the last usec
 289           if (time_usec > 0 && (usec_total - time_usec) >= 0.5)
 290             {
 291               ++time_usec;
 292             }
 293           else if (time_usec < 0 && (usec_total - time_usec) <= -0.5)
 294             {
 295               --time_usec;
 296             }
 297
 298           this->set (time_sec, time_usec);
 299         }
 300     }
 301   return *this;
 302 }
 303
 304 std::ostream &operator<<(std::ostream &o, const ACE_Time_Value &v)
 305 {
 306   char const oldFiller = o.fill ();
 307   o.fill ('0');
 308   const timeval *tv = v;
 309   if (tv->tv_sec)
 310     {
 311       o << tv->tv_sec;
 312       if (tv->tv_usec)
 313         o << '.' << std::setw (6) << std::labs (tv->tv_usec);
 314     }
 315   else if (tv->tv_usec < 0)
 316     o << "-0." << std::setw (6) << - tv->tv_usec;
 317   else
 318     {
 319       o << '0';
 320       if (tv->tv_usec > 0)
 321         o << '.'<< std::setw (6) << tv->tv_usec;
 322     }
 323
 324   o.fill (oldFiller);
 325   return o;
 326 }
 327
 328 ACE_END_VERSIONED_NAMESPACE_DECL