Use CLOCK_REALTIME_COARSE when available.

src/base/platform/time.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/platform/time.h"
 
 #if V8_OS_POSIX
 #include <fcntl.h>  // for O_RDONLY
 #include <sys/time.h>
 #include <unistd.h>
 #endif
 #if V8_OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 
 #include <cstring>
 #include <ostream>
 
 #if V8_OS_WIN
 #include "src/base/lazy-instance.h"
 #include "src/base/win32-headers.h"
 #endif
 #include "src/base/cpu.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 
+// CLOCK_REALTIME_COARSE was added in Linux 2.6.32.
+#if V8_OS_LINUX && !defined(CLOCK_REALTIME_COARSE)
+#define CLOCK_REALTIME_COARSE 5
+#endif
+
 namespace v8 {
 namespace base {
 
 TimeDelta TimeDelta::FromDays(int days) {
   return TimeDelta(days * Time::kMicrosecondsPerDay);
 }
 
 
 TimeDelta TimeDelta::FromHours(int hours) {
   return TimeDelta(hours * Time::kMicrosecondsPerHour);
@@ skipping 208 matching lines @@
   }
   uint64_t us = static_cast<uint64_t>(us_ + kTimeToEpochInMicroseconds) * 10;
   ft.dwLowDateTime = static_cast<DWORD>(us);
   ft.dwHighDateTime = static_cast<DWORD>(us >> 32);
   return ft;
 }
 
 #elif V8_OS_POSIX
 
 Time Time::Now() {
+#ifdef CLOCK_REALTIME_COARSE
+  struct timespec ts;
+  // clockid_t is an int32_t; loads and stores are atomic.

[mdempsky, 2015/05/07 18:47:29]

No, they're not.  Using atomics is atomic.

+  static const clockid_t kInvalidClockId = static_cast<clockid_t>(-1);
+  static clockid_t clock_id = kInvalidClockId;
+  if (V8_UNLIKELY(clock_id == kInvalidClockId)) {
+    // CLOCK_REALTIME_COARSE is not supported on Linux kernels < 2.6.32.
+    // Probe the kernel to see if it's available and has <= 1 ms resolution.
+    //
+    // CLOCK_REALTIME_COARSE, unlike CLOCK_REALTIME, can often be serviced
+    // entirely from the vDSO without the need to make a system call.
+    // It can have a dramatic impact on applications that frequently
+    // query the current time.
+    //
+    // One caveat is that CLOCK_REALTIME_COARSE is tied to CONFIG_HZ, the
+    // number of ticks per second that the kernel runs at.  Its granularity
+    // can be as low as one update every 300 ms so we need to make sure that
+    // it is accurate enough.  Fortunately, many if not most kernels are built
+    // with CONFIG_HZ=1000, giving it a one millisecond precision and that is
+    // good enough for our purposes.
+    if (clock_getres(CLOCK_REALTIME_COARSE, &ts) < 0 || ts.tv_sec > 0 ||
+        ts.tv_nsec > 1000 * 1000) {
+      clock_id = CLOCK_REALTIME;  // Not available or not suitable.
+    } else {
+      clock_id = CLOCK_REALTIME_COARSE;
+    }
+  }
+  int result = clock_gettime(clock_id, &ts);
+  DCHECK_EQ(0, result);
+  USE(result);
+  return FromTimespec(ts);
+#else
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
   DCHECK_EQ(0, result);
   USE(result);
   return FromTimeval(tv);
+#endif
 }
 
 
 Time Time::NowFromSystemTime() {
   return Now();
 }
 
 
 Time Time::FromTimespec(struct timespec ts) {
   DCHECK(ts.tv_nsec >= 0);
@@ skipping 368 matching lines @@
 
 
 // static
 bool TimeTicks::KernelTimestampAvailable() {
   return kernel_tick_clock.Pointer()->Available();
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::base