Revert "Use CLOCK_MONOTONIC_COARSE and CLOCK_REALTIME_COARSE on Linux if available."

src/platform/time.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 25 matching lines @@
 
 #include <cstring>
 
 #include "checks.h"
 #include "cpu.h"
 #include "platform.h"
 #if V8_OS_WIN
 #include "win32-headers.h"
 #endif
 
-#if V8_OS_LINUX
-#if !defined(CLOCK_REALTIME_COARSE)
-#define CLOCK_REALTIME_COARSE 5   // 2.6.32 and up.
-#endif  // !defined(CLOCK_REALTIME_COARSE)
-#if !defined(CLOCK_MONOTONIC_COARSE)
-#define CLOCK_MONOTONIC_COARSE 6  // 2.6.32 and up.
-#endif  // !defined(CLOCK_MONOTONIC_COARSE)
-#endif  // V8_OS_LINUX
-
 namespace v8 {
 namespace internal {
 
 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() {
-#if V8_OS_LINUX
-  // Use CLOCK_REALTIME_COARSE if it's available and has a precision of 1 ms
-  // or higher.  It's serviced from the vDSO with no system call overhead.
-  static clock_t clock_id = -1;
-  struct timespec ts;
-  if (clock_id == -1) {
-    if (clock_getres(CLOCK_REALTIME_COARSE, &ts) || ts.tv_nsec > 1000 * 1000) {
-      clock_id = CLOCK_REALTIME;
-    } else {
-      clock_id = CLOCK_REALTIME_COARSE;
-    }
-  }
-  int result = clock_gettime(clock_id, &ts);
-  ASSERT_EQ(0, result);
-  USE(result);
-  return FromTimespec(ts);
-#else  // V8_OS_LINUX
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
   ASSERT_EQ(0, result);
   USE(result);
   return FromTimeval(tv);
-#endif  // V8_OS_LINUX
 }
 
 
 Time Time::NowFromSystemTime() {
   return Now();
 }
 
 
 Time Time::FromTimespec(struct timespec ts) {
   ASSERT(ts.tv_nsec >= 0);
@@ skipping 274 matching lines @@
   // TODO(bmeurer): This is a temporary hack to support cross-compiling
   // Chrome for Android in AOSP. Remove this once AOSP is fixed, also
   // cleanup the tools/gyp/v8.gyp file.
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
   ASSERT_EQ(0, result);
   USE(result);
   ticks = (tv.tv_sec * Time::kMicrosecondsPerSecond + tv.tv_usec);
 #elif V8_OS_POSIX
   struct timespec ts;
-#if V8_OS_LINUX
-  // Use CLOCK_MONOTONIC_COARSE if it's available and has a precision of 1 ms
-  // or higher.  It's serviced from the vDSO with no system call overhead.
-  static clock_t clock_id = -1;
-  if (clock_id == -1) {
-    if (clock_getres(CLOCK_MONOTONIC_COARSE, &ts) || ts.tv_nsec > 1000 * 1000) {
-      clock_id = CLOCK_MONOTONIC;
-    } else {
-      clock_id = CLOCK_MONOTONIC_COARSE;
-    }
-  }
-  int result = clock_gettime(clock_id, &ts);
-#else
   int result = clock_gettime(CLOCK_MONOTONIC, &ts);
-#endif  // V8_OS_LINUX
   ASSERT_EQ(0, result);
   USE(result);
   ticks = (ts.tv_sec * Time::kMicrosecondsPerSecond +
            ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
 #endif  // V8_OS_MACOSX
   // Make sure we never return 0 here.
   return TimeTicks(ticks + 1);
 }
 
 
 // static
 bool TimeTicks::IsHighResolutionClockWorking() {
   return true;
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::internal