Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(172)

Side by Side Diff: src/platform/time.cc

Issue 358363002: Move platform abstraction to base library (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: updates Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(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 #include "src/platform/time.h"
6
7 #if V8_OS_POSIX
8 #include <sys/time.h>
9 #endif
10 #if V8_OS_MACOSX
11 #include <mach/mach_time.h>
12 #endif
13
14 #include <string.h>
15
16 #if V8_OS_WIN
17 #include "src/base/lazy-instance.h"
18 #include "src/base/win32-headers.h"
19 #endif
20 #include "src/checks.h"
21 #include "src/cpu.h"
22 #include "src/platform.h"
23
24 namespace v8 {
25 namespace internal {
26
27 TimeDelta TimeDelta::FromDays(int days) {
28 return TimeDelta(days * Time::kMicrosecondsPerDay);
29 }
30
31
32 TimeDelta TimeDelta::FromHours(int hours) {
33 return TimeDelta(hours * Time::kMicrosecondsPerHour);
34 }
35
36
37 TimeDelta TimeDelta::FromMinutes(int minutes) {
38 return TimeDelta(minutes * Time::kMicrosecondsPerMinute);
39 }
40
41
42 TimeDelta TimeDelta::FromSeconds(int64_t seconds) {
43 return TimeDelta(seconds * Time::kMicrosecondsPerSecond);
44 }
45
46
47 TimeDelta TimeDelta::FromMilliseconds(int64_t milliseconds) {
48 return TimeDelta(milliseconds * Time::kMicrosecondsPerMillisecond);
49 }
50
51
52 TimeDelta TimeDelta::FromNanoseconds(int64_t nanoseconds) {
53 return TimeDelta(nanoseconds / Time::kNanosecondsPerMicrosecond);
54 }
55
56
57 int TimeDelta::InDays() const {
58 return static_cast<int>(delta_ / Time::kMicrosecondsPerDay);
59 }
60
61
62 int TimeDelta::InHours() const {
63 return static_cast<int>(delta_ / Time::kMicrosecondsPerHour);
64 }
65
66
67 int TimeDelta::InMinutes() const {
68 return static_cast<int>(delta_ / Time::kMicrosecondsPerMinute);
69 }
70
71
72 double TimeDelta::InSecondsF() const {
73 return static_cast<double>(delta_) / Time::kMicrosecondsPerSecond;
74 }
75
76
77 int64_t TimeDelta::InSeconds() const {
78 return delta_ / Time::kMicrosecondsPerSecond;
79 }
80
81
82 double TimeDelta::InMillisecondsF() const {
83 return static_cast<double>(delta_) / Time::kMicrosecondsPerMillisecond;
84 }
85
86
87 int64_t TimeDelta::InMilliseconds() const {
88 return delta_ / Time::kMicrosecondsPerMillisecond;
89 }
90
91
92 int64_t TimeDelta::InNanoseconds() const {
93 return delta_ * Time::kNanosecondsPerMicrosecond;
94 }
95
96
97 #if V8_OS_MACOSX
98
99 TimeDelta TimeDelta::FromMachTimespec(struct mach_timespec ts) {
100 ASSERT_GE(ts.tv_nsec, 0);
101 ASSERT_LT(ts.tv_nsec,
102 static_cast<long>(Time::kNanosecondsPerSecond)); // NOLINT
103 return TimeDelta(ts.tv_sec * Time::kMicrosecondsPerSecond +
104 ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
105 }
106
107
108 struct mach_timespec TimeDelta::ToMachTimespec() const {
109 struct mach_timespec ts;
110 ASSERT(delta_ >= 0);
111 ts.tv_sec = delta_ / Time::kMicrosecondsPerSecond;
112 ts.tv_nsec = (delta_ % Time::kMicrosecondsPerSecond) *
113 Time::kNanosecondsPerMicrosecond;
114 return ts;
115 }
116
117 #endif // V8_OS_MACOSX
118
119
120 #if V8_OS_POSIX
121
122 TimeDelta TimeDelta::FromTimespec(struct timespec ts) {
123 ASSERT_GE(ts.tv_nsec, 0);
124 ASSERT_LT(ts.tv_nsec,
125 static_cast<long>(Time::kNanosecondsPerSecond)); // NOLINT
126 return TimeDelta(ts.tv_sec * Time::kMicrosecondsPerSecond +
127 ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
128 }
129
130
131 struct timespec TimeDelta::ToTimespec() const {
132 struct timespec ts;
133 ts.tv_sec = delta_ / Time::kMicrosecondsPerSecond;
134 ts.tv_nsec = (delta_ % Time::kMicrosecondsPerSecond) *
135 Time::kNanosecondsPerMicrosecond;
136 return ts;
137 }
138
139 #endif // V8_OS_POSIX
140
141
142 #if V8_OS_WIN
143
144 // We implement time using the high-resolution timers so that we can get
145 // timeouts which are smaller than 10-15ms. To avoid any drift, we
146 // periodically resync the internal clock to the system clock.
147 class Clock V8_FINAL {
148 public:
149 Clock() : initial_ticks_(GetSystemTicks()), initial_time_(GetSystemTime()) {}
150
151 Time Now() {
152 // Time between resampling the un-granular clock for this API (1 minute).
153 const TimeDelta kMaxElapsedTime = TimeDelta::FromMinutes(1);
154
155 LockGuard<Mutex> lock_guard(&mutex_);
156
157 // Determine current time and ticks.
158 TimeTicks ticks = GetSystemTicks();
159 Time time = GetSystemTime();
160
161 // Check if we need to synchronize with the system clock due to a backwards
162 // time change or the amount of time elapsed.
163 TimeDelta elapsed = ticks - initial_ticks_;
164 if (time < initial_time_ || elapsed > kMaxElapsedTime) {
165 initial_ticks_ = ticks;
166 initial_time_ = time;
167 return time;
168 }
169
170 return initial_time_ + elapsed;
171 }
172
173 Time NowFromSystemTime() {
174 LockGuard<Mutex> lock_guard(&mutex_);
175 initial_ticks_ = GetSystemTicks();
176 initial_time_ = GetSystemTime();
177 return initial_time_;
178 }
179
180 private:
181 static TimeTicks GetSystemTicks() {
182 return TimeTicks::Now();
183 }
184
185 static Time GetSystemTime() {
186 FILETIME ft;
187 ::GetSystemTimeAsFileTime(&ft);
188 return Time::FromFiletime(ft);
189 }
190
191 TimeTicks initial_ticks_;
192 Time initial_time_;
193 Mutex mutex_;
194 };
195
196
197 static base::LazyStaticInstance<Clock, base::DefaultConstructTrait<Clock>,
198 base::ThreadSafeInitOnceTrait>::type clock =
199 LAZY_STATIC_INSTANCE_INITIALIZER;
200
201
202 Time Time::Now() {
203 return clock.Pointer()->Now();
204 }
205
206
207 Time Time::NowFromSystemTime() {
208 return clock.Pointer()->NowFromSystemTime();
209 }
210
211
212 // Time between windows epoch and standard epoch.
213 static const int64_t kTimeToEpochInMicroseconds = V8_INT64_C(11644473600000000);
214
215
216 Time Time::FromFiletime(FILETIME ft) {
217 if (ft.dwLowDateTime == 0 && ft.dwHighDateTime == 0) {
218 return Time();
219 }
220 if (ft.dwLowDateTime == std::numeric_limits<DWORD>::max() &&
221 ft.dwHighDateTime == std::numeric_limits<DWORD>::max()) {
222 return Max();
223 }
224 int64_t us = (static_cast<uint64_t>(ft.dwLowDateTime) +
225 (static_cast<uint64_t>(ft.dwHighDateTime) << 32)) / 10;
226 return Time(us - kTimeToEpochInMicroseconds);
227 }
228
229
230 FILETIME Time::ToFiletime() const {
231 ASSERT(us_ >= 0);
232 FILETIME ft;
233 if (IsNull()) {
234 ft.dwLowDateTime = 0;
235 ft.dwHighDateTime = 0;
236 return ft;
237 }
238 if (IsMax()) {
239 ft.dwLowDateTime = std::numeric_limits<DWORD>::max();
240 ft.dwHighDateTime = std::numeric_limits<DWORD>::max();
241 return ft;
242 }
243 uint64_t us = static_cast<uint64_t>(us_ + kTimeToEpochInMicroseconds) * 10;
244 ft.dwLowDateTime = static_cast<DWORD>(us);
245 ft.dwHighDateTime = static_cast<DWORD>(us >> 32);
246 return ft;
247 }
248
249 #elif V8_OS_POSIX
250
251 Time Time::Now() {
252 struct timeval tv;
253 int result = gettimeofday(&tv, NULL);
254 ASSERT_EQ(0, result);
255 USE(result);
256 return FromTimeval(tv);
257 }
258
259
260 Time Time::NowFromSystemTime() {
261 return Now();
262 }
263
264
265 Time Time::FromTimespec(struct timespec ts) {
266 ASSERT(ts.tv_nsec >= 0);
267 ASSERT(ts.tv_nsec < static_cast<long>(kNanosecondsPerSecond)); // NOLINT
268 if (ts.tv_nsec == 0 && ts.tv_sec == 0) {
269 return Time();
270 }
271 if (ts.tv_nsec == static_cast<long>(kNanosecondsPerSecond - 1) && // NOLINT
272 ts.tv_sec == std::numeric_limits<time_t>::max()) {
273 return Max();
274 }
275 return Time(ts.tv_sec * kMicrosecondsPerSecond +
276 ts.tv_nsec / kNanosecondsPerMicrosecond);
277 }
278
279
280 struct timespec Time::ToTimespec() const {
281 struct timespec ts;
282 if (IsNull()) {
283 ts.tv_sec = 0;
284 ts.tv_nsec = 0;
285 return ts;
286 }
287 if (IsMax()) {
288 ts.tv_sec = std::numeric_limits<time_t>::max();
289 ts.tv_nsec = static_cast<long>(kNanosecondsPerSecond - 1); // NOLINT
290 return ts;
291 }
292 ts.tv_sec = us_ / kMicrosecondsPerSecond;
293 ts.tv_nsec = (us_ % kMicrosecondsPerSecond) * kNanosecondsPerMicrosecond;
294 return ts;
295 }
296
297
298 Time Time::FromTimeval(struct timeval tv) {
299 ASSERT(tv.tv_usec >= 0);
300 ASSERT(tv.tv_usec < static_cast<suseconds_t>(kMicrosecondsPerSecond));
301 if (tv.tv_usec == 0 && tv.tv_sec == 0) {
302 return Time();
303 }
304 if (tv.tv_usec == static_cast<suseconds_t>(kMicrosecondsPerSecond - 1) &&
305 tv.tv_sec == std::numeric_limits<time_t>::max()) {
306 return Max();
307 }
308 return Time(tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec);
309 }
310
311
312 struct timeval Time::ToTimeval() const {
313 struct timeval tv;
314 if (IsNull()) {
315 tv.tv_sec = 0;
316 tv.tv_usec = 0;
317 return tv;
318 }
319 if (IsMax()) {
320 tv.tv_sec = std::numeric_limits<time_t>::max();
321 tv.tv_usec = static_cast<suseconds_t>(kMicrosecondsPerSecond - 1);
322 return tv;
323 }
324 tv.tv_sec = us_ / kMicrosecondsPerSecond;
325 tv.tv_usec = us_ % kMicrosecondsPerSecond;
326 return tv;
327 }
328
329 #endif // V8_OS_WIN
330
331
332 Time Time::FromJsTime(double ms_since_epoch) {
333 // The epoch is a valid time, so this constructor doesn't interpret
334 // 0 as the null time.
335 if (ms_since_epoch == std::numeric_limits<double>::max()) {
336 return Max();
337 }
338 return Time(
339 static_cast<int64_t>(ms_since_epoch * kMicrosecondsPerMillisecond));
340 }
341
342
343 double Time::ToJsTime() const {
344 if (IsNull()) {
345 // Preserve 0 so the invalid result doesn't depend on the platform.
346 return 0;
347 }
348 if (IsMax()) {
349 // Preserve max without offset to prevent overflow.
350 return std::numeric_limits<double>::max();
351 }
352 return static_cast<double>(us_) / kMicrosecondsPerMillisecond;
353 }
354
355
356 #if V8_OS_WIN
357
358 class TickClock {
359 public:
360 virtual ~TickClock() {}
361 virtual int64_t Now() = 0;
362 virtual bool IsHighResolution() = 0;
363 };
364
365
366 // Overview of time counters:
367 // (1) CPU cycle counter. (Retrieved via RDTSC)
368 // The CPU counter provides the highest resolution time stamp and is the least
369 // expensive to retrieve. However, the CPU counter is unreliable and should not
370 // be used in production. Its biggest issue is that it is per processor and it
371 // is not synchronized between processors. Also, on some computers, the counters
372 // will change frequency due to thermal and power changes, and stop in some
373 // states.
374 //
375 // (2) QueryPerformanceCounter (QPC). The QPC counter provides a high-
376 // resolution (100 nanoseconds) time stamp but is comparatively more expensive
377 // to retrieve. What QueryPerformanceCounter actually does is up to the HAL.
378 // (with some help from ACPI).
379 // According to http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx
380 // in the worst case, it gets the counter from the rollover interrupt on the
381 // programmable interrupt timer. In best cases, the HAL may conclude that the
382 // RDTSC counter runs at a constant frequency, then it uses that instead. On
383 // multiprocessor machines, it will try to verify the values returned from
384 // RDTSC on each processor are consistent with each other, and apply a handful
385 // of workarounds for known buggy hardware. In other words, QPC is supposed to
386 // give consistent result on a multiprocessor computer, but it is unreliable in
387 // reality due to bugs in BIOS or HAL on some, especially old computers.
388 // With recent updates on HAL and newer BIOS, QPC is getting more reliable but
389 // it should be used with caution.
390 //
391 // (3) System time. The system time provides a low-resolution (typically 10ms
392 // to 55 milliseconds) time stamp but is comparatively less expensive to
393 // retrieve and more reliable.
394 class HighResolutionTickClock V8_FINAL : public TickClock {
395 public:
396 explicit HighResolutionTickClock(int64_t ticks_per_second)
397 : ticks_per_second_(ticks_per_second) {
398 ASSERT_LT(0, ticks_per_second);
399 }
400 virtual ~HighResolutionTickClock() {}
401
402 virtual int64_t Now() V8_OVERRIDE {
403 LARGE_INTEGER now;
404 BOOL result = QueryPerformanceCounter(&now);
405 ASSERT(result);
406 USE(result);
407
408 // Intentionally calculate microseconds in a round about manner to avoid
409 // overflow and precision issues. Think twice before simplifying!
410 int64_t whole_seconds = now.QuadPart / ticks_per_second_;
411 int64_t leftover_ticks = now.QuadPart % ticks_per_second_;
412 int64_t ticks = (whole_seconds * Time::kMicrosecondsPerSecond) +
413 ((leftover_ticks * Time::kMicrosecondsPerSecond) / ticks_per_second_);
414
415 // Make sure we never return 0 here, so that TimeTicks::HighResolutionNow()
416 // will never return 0.
417 return ticks + 1;
418 }
419
420 virtual bool IsHighResolution() V8_OVERRIDE {
421 return true;
422 }
423
424 private:
425 int64_t ticks_per_second_;
426 };
427
428
429 class RolloverProtectedTickClock V8_FINAL : public TickClock {
430 public:
431 // We initialize rollover_ms_ to 1 to ensure that we will never
432 // return 0 from TimeTicks::HighResolutionNow() and TimeTicks::Now() below.
433 RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
434 virtual ~RolloverProtectedTickClock() {}
435
436 virtual int64_t Now() V8_OVERRIDE {
437 LockGuard<Mutex> lock_guard(&mutex_);
438 // We use timeGetTime() to implement TimeTicks::Now(), which rolls over
439 // every ~49.7 days. We try to track rollover ourselves, which works if
440 // TimeTicks::Now() is called at least every 49 days.
441 // Note that we do not use GetTickCount() here, since timeGetTime() gives
442 // more predictable delta values, as described here:
443 // http://blogs.msdn.com/b/larryosterman/archive/2009/09/02/what-s-the-diffe rence-between-gettickcount-and-timegettime.aspx
444 // timeGetTime() provides 1ms granularity when combined with
445 // timeBeginPeriod(). If the host application for V8 wants fast timers, it
446 // can use timeBeginPeriod() to increase the resolution.
447 DWORD now = timeGetTime();
448 if (now < last_seen_now_) {
449 rollover_ms_ += V8_INT64_C(0x100000000); // ~49.7 days.
450 }
451 last_seen_now_ = now;
452 return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
453 }
454
455 virtual bool IsHighResolution() V8_OVERRIDE {
456 return false;
457 }
458
459 private:
460 Mutex mutex_;
461 DWORD last_seen_now_;
462 int64_t rollover_ms_;
463 };
464
465
466 static base::LazyStaticInstance<
467 RolloverProtectedTickClock,
468 base::DefaultConstructTrait<RolloverProtectedTickClock>,
469 base::ThreadSafeInitOnceTrait>::type tick_clock =
470 LAZY_STATIC_INSTANCE_INITIALIZER;
471
472
473 struct CreateHighResTickClockTrait {
474 static TickClock* Create() {
475 // Check if the installed hardware supports a high-resolution performance
476 // counter, and if not fallback to the low-resolution tick clock.
477 LARGE_INTEGER ticks_per_second;
478 if (!QueryPerformanceFrequency(&ticks_per_second)) {
479 return tick_clock.Pointer();
480 }
481
482 // On Athlon X2 CPUs (e.g. model 15) the QueryPerformanceCounter
483 // is unreliable, fallback to the low-resolution tick clock.
484 CPU cpu;
485 if (strcmp(cpu.vendor(), "AuthenticAMD") == 0 && cpu.family() == 15) {
486 return tick_clock.Pointer();
487 }
488
489 return new HighResolutionTickClock(ticks_per_second.QuadPart);
490 }
491 };
492
493
494 static base::LazyDynamicInstance<TickClock,
495 CreateHighResTickClockTrait,
496 base::ThreadSafeInitOnceTrait>::type high_res_tick_clock =
497 LAZY_DYNAMIC_INSTANCE_INITIALIZER;
498
499
500 TimeTicks TimeTicks::Now() {
501 // Make sure we never return 0 here.
502 TimeTicks ticks(tick_clock.Pointer()->Now());
503 ASSERT(!ticks.IsNull());
504 return ticks;
505 }
506
507
508 TimeTicks TimeTicks::HighResolutionNow() {
509 // Make sure we never return 0 here.
510 TimeTicks ticks(high_res_tick_clock.Pointer()->Now());
511 ASSERT(!ticks.IsNull());
512 return ticks;
513 }
514
515
516 // static
517 bool TimeTicks::IsHighResolutionClockWorking() {
518 return high_res_tick_clock.Pointer()->IsHighResolution();
519 }
520
521 #else // V8_OS_WIN
522
523 TimeTicks TimeTicks::Now() {
524 return HighResolutionNow();
525 }
526
527
528 TimeTicks TimeTicks::HighResolutionNow() {
529 int64_t ticks;
530 #if V8_OS_MACOSX
531 static struct mach_timebase_info info;
532 if (info.denom == 0) {
533 kern_return_t result = mach_timebase_info(&info);
534 ASSERT_EQ(KERN_SUCCESS, result);
535 USE(result);
536 }
537 ticks = (mach_absolute_time() / Time::kNanosecondsPerMicrosecond *
538 info.numer / info.denom);
539 #elif V8_OS_SOLARIS
540 ticks = (gethrtime() / Time::kNanosecondsPerMicrosecond);
541 #elif V8_LIBRT_NOT_AVAILABLE
542 // TODO(bmeurer): This is a temporary hack to support cross-compiling
543 // Chrome for Android in AOSP. Remove this once AOSP is fixed, also
544 // cleanup the tools/gyp/v8.gyp file.
545 struct timeval tv;
546 int result = gettimeofday(&tv, NULL);
547 ASSERT_EQ(0, result);
548 USE(result);
549 ticks = (tv.tv_sec * Time::kMicrosecondsPerSecond + tv.tv_usec);
550 #elif V8_OS_POSIX
551 struct timespec ts;
552 int result = clock_gettime(CLOCK_MONOTONIC, &ts);
553 ASSERT_EQ(0, result);
554 USE(result);
555 ticks = (ts.tv_sec * Time::kMicrosecondsPerSecond +
556 ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
557 #endif // V8_OS_MACOSX
558 // Make sure we never return 0 here.
559 return TimeTicks(ticks + 1);
560 }
561
562
563 // static
564 bool TimeTicks::IsHighResolutionClockWorking() {
565 return true;
566 }
567
568 #endif // V8_OS_WIN
569
570 } } // namespace v8::internal
OLDNEW
« src/base/macros.h ('K') | « src/platform/time.h ('k') | src/preparse-data.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698