| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 the V8 project authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef V8_PLATFORM_TIME_H_ | |
| 6 #define V8_PLATFORM_TIME_H_ | |
| 7 | |
| 8 #include <time.h> | |
| 9 #include <limits> | |
| 10 | |
| 11 #include "src/base/macros.h" | |
| 12 | |
| 13 // Forward declarations. | |
| 14 extern "C" { | |
| 15 struct _FILETIME; | |
| 16 struct mach_timespec; | |
| 17 struct timespec; | |
| 18 struct timeval; | |
| 19 } | |
| 20 | |
| 21 namespace v8 { | |
| 22 namespace internal { | |
| 23 | |
| 24 class Time; | |
| 25 class TimeTicks; | |
| 26 | |
| 27 // ----------------------------------------------------------------------------- | |
| 28 // TimeDelta | |
| 29 // | |
| 30 // This class represents a duration of time, internally represented in | |
| 31 // microseonds. | |
| 32 | |
| 33 class TimeDelta V8_FINAL { | |
| 34 public: | |
| 35 TimeDelta() : delta_(0) {} | |
| 36 | |
| 37 // Converts units of time to TimeDeltas. | |
| 38 static TimeDelta FromDays(int days); | |
| 39 static TimeDelta FromHours(int hours); | |
| 40 static TimeDelta FromMinutes(int minutes); | |
| 41 static TimeDelta FromSeconds(int64_t seconds); | |
| 42 static TimeDelta FromMilliseconds(int64_t milliseconds); | |
| 43 static TimeDelta FromMicroseconds(int64_t microseconds) { | |
| 44 return TimeDelta(microseconds); | |
| 45 } | |
| 46 static TimeDelta FromNanoseconds(int64_t nanoseconds); | |
| 47 | |
| 48 // Returns the time delta in some unit. The F versions return a floating | |
| 49 // point value, the "regular" versions return a rounded-down value. | |
| 50 // | |
| 51 // InMillisecondsRoundedUp() instead returns an integer that is rounded up | |
| 52 // to the next full millisecond. | |
| 53 int InDays() const; | |
| 54 int InHours() const; | |
| 55 int InMinutes() const; | |
| 56 double InSecondsF() const; | |
| 57 int64_t InSeconds() const; | |
| 58 double InMillisecondsF() const; | |
| 59 int64_t InMilliseconds() const; | |
| 60 int64_t InMillisecondsRoundedUp() const; | |
| 61 int64_t InMicroseconds() const { return delta_; } | |
| 62 int64_t InNanoseconds() const; | |
| 63 | |
| 64 // Converts to/from Mach time specs. | |
| 65 static TimeDelta FromMachTimespec(struct mach_timespec ts); | |
| 66 struct mach_timespec ToMachTimespec() const; | |
| 67 | |
| 68 // Converts to/from POSIX time specs. | |
| 69 static TimeDelta FromTimespec(struct timespec ts); | |
| 70 struct timespec ToTimespec() const; | |
| 71 | |
| 72 TimeDelta& operator=(const TimeDelta& other) { | |
| 73 delta_ = other.delta_; | |
| 74 return *this; | |
| 75 } | |
| 76 | |
| 77 // Computations with other deltas. | |
| 78 TimeDelta operator+(const TimeDelta& other) const { | |
| 79 return TimeDelta(delta_ + other.delta_); | |
| 80 } | |
| 81 TimeDelta operator-(const TimeDelta& other) const { | |
| 82 return TimeDelta(delta_ - other.delta_); | |
| 83 } | |
| 84 | |
| 85 TimeDelta& operator+=(const TimeDelta& other) { | |
| 86 delta_ += other.delta_; | |
| 87 return *this; | |
| 88 } | |
| 89 TimeDelta& operator-=(const TimeDelta& other) { | |
| 90 delta_ -= other.delta_; | |
| 91 return *this; | |
| 92 } | |
| 93 TimeDelta operator-() const { | |
| 94 return TimeDelta(-delta_); | |
| 95 } | |
| 96 | |
| 97 double TimesOf(const TimeDelta& other) const { | |
| 98 return static_cast<double>(delta_) / static_cast<double>(other.delta_); | |
| 99 } | |
| 100 double PercentOf(const TimeDelta& other) const { | |
| 101 return TimesOf(other) * 100.0; | |
| 102 } | |
| 103 | |
| 104 // Computations with ints, note that we only allow multiplicative operations | |
| 105 // with ints, and additive operations with other deltas. | |
| 106 TimeDelta operator*(int64_t a) const { | |
| 107 return TimeDelta(delta_ * a); | |
| 108 } | |
| 109 TimeDelta operator/(int64_t a) const { | |
| 110 return TimeDelta(delta_ / a); | |
| 111 } | |
| 112 TimeDelta& operator*=(int64_t a) { | |
| 113 delta_ *= a; | |
| 114 return *this; | |
| 115 } | |
| 116 TimeDelta& operator/=(int64_t a) { | |
| 117 delta_ /= a; | |
| 118 return *this; | |
| 119 } | |
| 120 int64_t operator/(const TimeDelta& other) const { | |
| 121 return delta_ / other.delta_; | |
| 122 } | |
| 123 | |
| 124 // Comparison operators. | |
| 125 bool operator==(const TimeDelta& other) const { | |
| 126 return delta_ == other.delta_; | |
| 127 } | |
| 128 bool operator!=(const TimeDelta& other) const { | |
| 129 return delta_ != other.delta_; | |
| 130 } | |
| 131 bool operator<(const TimeDelta& other) const { | |
| 132 return delta_ < other.delta_; | |
| 133 } | |
| 134 bool operator<=(const TimeDelta& other) const { | |
| 135 return delta_ <= other.delta_; | |
| 136 } | |
| 137 bool operator>(const TimeDelta& other) const { | |
| 138 return delta_ > other.delta_; | |
| 139 } | |
| 140 bool operator>=(const TimeDelta& other) const { | |
| 141 return delta_ >= other.delta_; | |
| 142 } | |
| 143 | |
| 144 private: | |
| 145 // Constructs a delta given the duration in microseconds. This is private | |
| 146 // to avoid confusion by callers with an integer constructor. Use | |
| 147 // FromSeconds, FromMilliseconds, etc. instead. | |
| 148 explicit TimeDelta(int64_t delta) : delta_(delta) {} | |
| 149 | |
| 150 // Delta in microseconds. | |
| 151 int64_t delta_; | |
| 152 }; | |
| 153 | |
| 154 | |
| 155 // ----------------------------------------------------------------------------- | |
| 156 // Time | |
| 157 // | |
| 158 // This class represents an absolute point in time, internally represented as | |
| 159 // microseconds (s/1,000,000) since 00:00:00 UTC, January 1, 1970. | |
| 160 | |
| 161 class Time V8_FINAL { | |
| 162 public: | |
| 163 static const int64_t kMillisecondsPerSecond = 1000; | |
| 164 static const int64_t kMicrosecondsPerMillisecond = 1000; | |
| 165 static const int64_t kMicrosecondsPerSecond = kMicrosecondsPerMillisecond * | |
| 166 kMillisecondsPerSecond; | |
| 167 static const int64_t kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60; | |
| 168 static const int64_t kMicrosecondsPerHour = kMicrosecondsPerMinute * 60; | |
| 169 static const int64_t kMicrosecondsPerDay = kMicrosecondsPerHour * 24; | |
| 170 static const int64_t kMicrosecondsPerWeek = kMicrosecondsPerDay * 7; | |
| 171 static const int64_t kNanosecondsPerMicrosecond = 1000; | |
| 172 static const int64_t kNanosecondsPerSecond = kNanosecondsPerMicrosecond * | |
| 173 kMicrosecondsPerSecond; | |
| 174 | |
| 175 // Contains the NULL time. Use Time::Now() to get the current time. | |
| 176 Time() : us_(0) {} | |
| 177 | |
| 178 // Returns true if the time object has not been initialized. | |
| 179 bool IsNull() const { return us_ == 0; } | |
| 180 | |
| 181 // Returns true if the time object is the maximum time. | |
| 182 bool IsMax() const { return us_ == std::numeric_limits<int64_t>::max(); } | |
| 183 | |
| 184 // Returns the current time. Watch out, the system might adjust its clock | |
| 185 // in which case time will actually go backwards. We don't guarantee that | |
| 186 // times are increasing, or that two calls to Now() won't be the same. | |
| 187 static Time Now(); | |
| 188 | |
| 189 // Returns the current time. Same as Now() except that this function always | |
| 190 // uses system time so that there are no discrepancies between the returned | |
| 191 // time and system time even on virtual environments including our test bot. | |
| 192 // For timing sensitive unittests, this function should be used. | |
| 193 static Time NowFromSystemTime(); | |
| 194 | |
| 195 // Returns the time for epoch in Unix-like system (Jan 1, 1970). | |
| 196 static Time UnixEpoch() { return Time(0); } | |
| 197 | |
| 198 // Returns the maximum time, which should be greater than any reasonable time | |
| 199 // with which we might compare it. | |
| 200 static Time Max() { return Time(std::numeric_limits<int64_t>::max()); } | |
| 201 | |
| 202 // Converts to/from internal values. The meaning of the "internal value" is | |
| 203 // completely up to the implementation, so it should be treated as opaque. | |
| 204 static Time FromInternalValue(int64_t value) { | |
| 205 return Time(value); | |
| 206 } | |
| 207 int64_t ToInternalValue() const { | |
| 208 return us_; | |
| 209 } | |
| 210 | |
| 211 // Converts to/from POSIX time specs. | |
| 212 static Time FromTimespec(struct timespec ts); | |
| 213 struct timespec ToTimespec() const; | |
| 214 | |
| 215 // Converts to/from POSIX time values. | |
| 216 static Time FromTimeval(struct timeval tv); | |
| 217 struct timeval ToTimeval() const; | |
| 218 | |
| 219 // Converts to/from Windows file times. | |
| 220 static Time FromFiletime(struct _FILETIME ft); | |
| 221 struct _FILETIME ToFiletime() const; | |
| 222 | |
| 223 // Converts to/from the Javascript convention for times, a number of | |
| 224 // milliseconds since the epoch: | |
| 225 static Time FromJsTime(double ms_since_epoch); | |
| 226 double ToJsTime() const; | |
| 227 | |
| 228 Time& operator=(const Time& other) { | |
| 229 us_ = other.us_; | |
| 230 return *this; | |
| 231 } | |
| 232 | |
| 233 // Compute the difference between two times. | |
| 234 TimeDelta operator-(const Time& other) const { | |
| 235 return TimeDelta::FromMicroseconds(us_ - other.us_); | |
| 236 } | |
| 237 | |
| 238 // Modify by some time delta. | |
| 239 Time& operator+=(const TimeDelta& delta) { | |
| 240 us_ += delta.InMicroseconds(); | |
| 241 return *this; | |
| 242 } | |
| 243 Time& operator-=(const TimeDelta& delta) { | |
| 244 us_ -= delta.InMicroseconds(); | |
| 245 return *this; | |
| 246 } | |
| 247 | |
| 248 // Return a new time modified by some delta. | |
| 249 Time operator+(const TimeDelta& delta) const { | |
| 250 return Time(us_ + delta.InMicroseconds()); | |
| 251 } | |
| 252 Time operator-(const TimeDelta& delta) const { | |
| 253 return Time(us_ - delta.InMicroseconds()); | |
| 254 } | |
| 255 | |
| 256 // Comparison operators | |
| 257 bool operator==(const Time& other) const { | |
| 258 return us_ == other.us_; | |
| 259 } | |
| 260 bool operator!=(const Time& other) const { | |
| 261 return us_ != other.us_; | |
| 262 } | |
| 263 bool operator<(const Time& other) const { | |
| 264 return us_ < other.us_; | |
| 265 } | |
| 266 bool operator<=(const Time& other) const { | |
| 267 return us_ <= other.us_; | |
| 268 } | |
| 269 bool operator>(const Time& other) const { | |
| 270 return us_ > other.us_; | |
| 271 } | |
| 272 bool operator>=(const Time& other) const { | |
| 273 return us_ >= other.us_; | |
| 274 } | |
| 275 | |
| 276 private: | |
| 277 explicit Time(int64_t us) : us_(us) {} | |
| 278 | |
| 279 // Time in microseconds in UTC. | |
| 280 int64_t us_; | |
| 281 }; | |
| 282 | |
| 283 inline Time operator+(const TimeDelta& delta, const Time& time) { | |
| 284 return time + delta; | |
| 285 } | |
| 286 | |
| 287 | |
| 288 // ----------------------------------------------------------------------------- | |
| 289 // TimeTicks | |
| 290 // | |
| 291 // This class represents an abstract time that is most of the time incrementing | |
| 292 // for use in measuring time durations. It is internally represented in | |
| 293 // microseconds. It can not be converted to a human-readable time, but is | |
| 294 // guaranteed not to decrease (if the user changes the computer clock, | |
| 295 // Time::Now() may actually decrease or jump). But note that TimeTicks may | |
| 296 // "stand still", for example if the computer suspended. | |
| 297 | |
| 298 class TimeTicks V8_FINAL { | |
| 299 public: | |
| 300 TimeTicks() : ticks_(0) {} | |
| 301 | |
| 302 // Platform-dependent tick count representing "right now." | |
| 303 // The resolution of this clock is ~1-15ms. Resolution varies depending | |
| 304 // on hardware/operating system configuration. | |
| 305 // This method never returns a null TimeTicks. | |
| 306 static TimeTicks Now(); | |
| 307 | |
| 308 // Returns a platform-dependent high-resolution tick count. Implementation | |
| 309 // is hardware dependent and may or may not return sub-millisecond | |
| 310 // resolution. THIS CALL IS GENERALLY MUCH MORE EXPENSIVE THAN Now() AND | |
| 311 // SHOULD ONLY BE USED WHEN IT IS REALLY NEEDED. | |
| 312 // This method never returns a null TimeTicks. | |
| 313 static TimeTicks HighResolutionNow(); | |
| 314 | |
| 315 // Returns true if the high-resolution clock is working on this system. | |
| 316 static bool IsHighResolutionClockWorking(); | |
| 317 | |
| 318 // Returns true if this object has not been initialized. | |
| 319 bool IsNull() const { return ticks_ == 0; } | |
| 320 | |
| 321 // Converts to/from internal values. The meaning of the "internal value" is | |
| 322 // completely up to the implementation, so it should be treated as opaque. | |
| 323 static TimeTicks FromInternalValue(int64_t value) { | |
| 324 return TimeTicks(value); | |
| 325 } | |
| 326 int64_t ToInternalValue() const { | |
| 327 return ticks_; | |
| 328 } | |
| 329 | |
| 330 TimeTicks& operator=(const TimeTicks other) { | |
| 331 ticks_ = other.ticks_; | |
| 332 return *this; | |
| 333 } | |
| 334 | |
| 335 // Compute the difference between two times. | |
| 336 TimeDelta operator-(const TimeTicks other) const { | |
| 337 return TimeDelta::FromMicroseconds(ticks_ - other.ticks_); | |
| 338 } | |
| 339 | |
| 340 // Modify by some time delta. | |
| 341 TimeTicks& operator+=(const TimeDelta& delta) { | |
| 342 ticks_ += delta.InMicroseconds(); | |
| 343 return *this; | |
| 344 } | |
| 345 TimeTicks& operator-=(const TimeDelta& delta) { | |
| 346 ticks_ -= delta.InMicroseconds(); | |
| 347 return *this; | |
| 348 } | |
| 349 | |
| 350 // Return a new TimeTicks modified by some delta. | |
| 351 TimeTicks operator+(const TimeDelta& delta) const { | |
| 352 return TimeTicks(ticks_ + delta.InMicroseconds()); | |
| 353 } | |
| 354 TimeTicks operator-(const TimeDelta& delta) const { | |
| 355 return TimeTicks(ticks_ - delta.InMicroseconds()); | |
| 356 } | |
| 357 | |
| 358 // Comparison operators | |
| 359 bool operator==(const TimeTicks& other) const { | |
| 360 return ticks_ == other.ticks_; | |
| 361 } | |
| 362 bool operator!=(const TimeTicks& other) const { | |
| 363 return ticks_ != other.ticks_; | |
| 364 } | |
| 365 bool operator<(const TimeTicks& other) const { | |
| 366 return ticks_ < other.ticks_; | |
| 367 } | |
| 368 bool operator<=(const TimeTicks& other) const { | |
| 369 return ticks_ <= other.ticks_; | |
| 370 } | |
| 371 bool operator>(const TimeTicks& other) const { | |
| 372 return ticks_ > other.ticks_; | |
| 373 } | |
| 374 bool operator>=(const TimeTicks& other) const { | |
| 375 return ticks_ >= other.ticks_; | |
| 376 } | |
| 377 | |
| 378 private: | |
| 379 // Please use Now() to create a new object. This is for internal use | |
| 380 // and testing. Ticks is in microseconds. | |
| 381 explicit TimeTicks(int64_t ticks) : ticks_(ticks) {} | |
| 382 | |
| 383 // Tick count in microseconds. | |
| 384 int64_t ticks_; | |
| 385 }; | |
| 386 | |
| 387 inline TimeTicks operator+(const TimeDelta& delta, const TimeTicks& ticks) { | |
| 388 return ticks + delta; | |
| 389 } | |
| 390 | |
| 391 } } // namespace v8::internal | |
| 392 | |
| 393 #endif // V8_PLATFORM_TIME_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 358363002:
Move platform abstraction to base library (Closed)
Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge