SERVER-13792 added runtime and build-time checks for POSIX monotonic clocks. de-inlined Timer::now() implementations

Author: benety

SConstruct

@@ -1343,6 +1343,32 @@ def doConfigure(myenv):
     posix_system = conf.CheckPosixSystem()
     conf.Finish()
 
+    # Check if we are on a system that support the POSIX clock_gettime function
+    #  and the "monotonic" clock.
+    posix_monotonic_clock = False
+    if posix_system:
+        def CheckPosixMonotonicClock(context):
+
+            test_body = """
+            #include <unistd.h>
+            #if !(defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
+            #error POSIX clock_gettime not supported
+            #elif !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0)
+            #error POSIX monotonic clock not supported
+            #endif
+            """
+
+            context.Message('Checking if the POSIX monotonic clock is supported... ')
+            ret = context.TryCompile(textwrap.dedent(test_body), ".c")
+            context.Result(ret)
+            return ret
+
+        conf = Configure(myenv, help=False, custom_tests = {
+            'CheckPosixMonotonicClock' : CheckPosixMonotonicClock,
+        })
+        posix_monotonic_clock = conf.CheckPosixMonotonicClock()
+        conf.Finish()
+
     if has_option('sanitize'):
 
         if not (using_clang() or using_gcc()):
@@ -1615,6 +1641,9 @@ def doConfigure(myenv):
         conf.CheckLib('rt')
         conf.CheckLib('dl')
 
+    if posix_monotonic_clock:
+        conf.env.Append(CPPDEFINES=['MONGO_HAVE_POSIX_MONOTONIC_CLOCK'])
+
     if (conf.CheckCXXHeader( "execinfo.h" ) and
         conf.CheckDeclaration('backtrace', includes='#include <execinfo.h>') and
         conf.CheckDeclaration('backtrace_symbols', includes='#include <execinfo.h>') and

src/mongo/util/timer-generic-inl.h

@@ -27,14 +27,25 @@
  *    then also delete it in the license file.
  */
 
+#include "mongo/platform/basic.h"
+
 #include "mongo/util/timer.h"
 
+#include <ctime>
 #include <limits>
+#if defined(MONGO_HAVE_HEADER_UNISTD_H)
+#include <unistd.h>
+#endif
+
+#include "mongo/util/assert_util.h"
+#include "mongo/util/time_support.h"
 
 namespace mongo {
 
-    // default value of 1 so that during startup initialization if referenced no division by zero
-    long long Timer::_countsPerSecond = 1;
+    // Set default value to reflect "generic" timer implementation.
+    // Define Timer::_countsPerSecond before static initializer "atstartuputil" to ensure correct
+    // relative sequencing regardless of how _countsPerSecond is initialized (static or dynamic).
+    long long Timer::_countsPerSecond = Timer::microsPerSecond;
 
     namespace {
 
@@ -43,19 +54,66 @@ namespace mongo {
             AtStartup();
         } atstartuputil;
 
-#if defined(MONGO_TIMER_IMPL_WIN32)
+        // "Generic" implementation for Timer::now().
+        long long _timerNowGeneric() {
+            return curTimeMicros64();
+        }
+
+        // Function pointer to Timer::now() implementation.
+        // Overridden in AtStartup() with better implementation where available.
+        long long (*_timerNow)() = &_timerNowGeneric;
+
+#if defined(_WIN32)
+
+        /**
+         * Windows-specific implementation of the
+         * Timer class.  Windows selects the best available timer, in its estimation, for
+         * measuring time at high resolution.  This may be the HPET of the TSC on x86 systems,
+         * but is promised to be synchronized across processors, barring BIOS errors.
+         */
+        long long timerNowWindows() {
+            LARGE_INTEGER i;
+            fassert(16161, QueryPerformanceCounter(&i));
+            return i.QuadPart;
+        }
 
         AtStartup::AtStartup() {
             LARGE_INTEGER x;
             bool ok = QueryPerformanceFrequency(&x);
             verify(ok);
             Timer::_countsPerSecond = x.QuadPart;
+            _timerNow = &timerNowWindows;
         }
 
-#elif defined(MONGO_TIMER_IMPL_POSIX_MONOTONIC_CLOCK)
+#elif defined(MONGO_HAVE_POSIX_MONOTONIC_CLOCK)
+
+        /**
+         * Implementation for timer on systems that support the
+         * POSIX clock API and CLOCK_MONOTONIC clock.
+         */
+        long long timerNowPosixMonotonicClock() {
+            timespec the_time;
+            long long result;
+
+            fassert(16160, !clock_gettime(CLOCK_MONOTONIC, &the_time));
+
+            // Safe for 292 years after the clock epoch, even if we switch to a signed time value.
+            // On Linux, the monotonic clock's epoch is the UNIX epoch.
+            result = static_cast<long long>(the_time.tv_sec);
+            result *= Timer::nanosPerSecond;
+            result += static_cast<long long>(the_time.tv_nsec);
+            return result;
+        }
 
         AtStartup::AtStartup() {
+            // If the monotonic clock is not available at runtime (sysconf() returns 0 or -1),
+            // do not override the generic implementation or modify Timer::_countsPerSecond.
+            if (sysconf(_SC_MONOTONIC_CLOCK) <= 0) {
+                return;
+            }
+
             Timer::_countsPerSecond = Timer::nanosPerSecond;
+            _timerNow = &timerNowPosixMonotonicClock;
 
             // Make sure that the current time relative to the (unspecified) epoch isn't already too
             // big to represent as a 64-bit count of nanoseconds.
@@ -65,17 +123,14 @@ namespace mongo {
             fassert(16162, !clock_gettime(CLOCK_MONOTONIC, &the_time));
             fassert(16163, static_cast<long long>(the_time.tv_sec) < maxSecs);
         }
-
-#elif defined(MONGO_TIMER_IMPL_GENERIC)
-
-        AtStartup::AtStartup() {
-            Timer::_countsPerSecond = Timer::microsPerSecond;
-        }
-
 #else
-#error "Unknown mongo::Timer implementation"
+        AtStartup::AtStartup() { }
 #endif
 
     }  // namespace
 
+    long long Timer::now() const {
+        return _timerNow();
+    }
+
 }  // namespace mongo

src/mongo/util/timer-inl.h

@@ -85,10 +85,8 @@ namespace mongo {
         static long long _countsPerSecond;
 
     private:
-        inline long long now() const;
+        long long now() const;
 
         long long _old;
     };
 }  // namespace mongo
-
-#include "mongo/util/timer-inl.h"