Use CLOCK_MONOTONIC_RAW over CLOCK_MONOTONIC on Linux (fixes non monotonic clock)

azat · azat · commit fa2074e67b42 · 2023-05-12T10:59:53.000+02:00
There is no bug in Linux, the issue that CLOCK_MONOTONIC returns values less then previous calls likely happens due to adjtime(3) (NTP), since CLOCK_MONOTONIC is affected by it, and I've seen lots of slight time modifications due to NTP on the servers. And even on my desktop (I also have NTP enabled): CLOCK_MONOTONIC: 189292.803 (2 days + 4h 34m 52s) CLOCK_MONOTONIC_RAW: 189290.016 (2 days + 4h 34m 50s) However on Linux there is CLOCK_MONOTONIC_RAW, it is similar to CLOCK_MONOTONIC, but does not affected by the adjtime(3). About performance, it is the same: CLOCK_MONOTONIC 10e6: real=0m0.191s user=0m0.190s sys=0m0.000s CLOCK_MONOTONIC_RAW 10e6: real=0m0.191s user=0m0.191s sys=0m0.000s Ops/s: - AMD Threadripper: 52.3e6 - Xeon Silver 4216 2.10: 46.5e6 Fixes: c5d631c Fixes: #29811 (cc @tavplubix) Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
diff --git a/src/Common/Stopwatch.h b/src/Common/Stopwatch.h
@@ -8,19 +8,34 @@
 #include <atomic>
 #include <memory>
 
-
-inline UInt64 clock_gettime_ns(clockid_t clock_type = CLOCK_MONOTONIC)
+/// From clock_getres(2):
+///
+///    Similar to CLOCK_MONOTONIC, but provides access to a raw hardware-based
+///    time that is not subject to NTP adjustments or the incremental
+///    adjustments performed by adjtime(3).
+#ifdef CLOCK_MONOTONIC_RAW
+static constexpr clockid_t STOPWATCH_DEFAULT_CLOCK = CLOCK_MONOTONIC_RAW;
+#else
+static constexpr clockid_t STOPWATCH_DEFAULT_CLOCK = CLOCK_MONOTONIC;
+#endif
+
+inline UInt64 clock_gettime_ns(clockid_t clock_type = STOPWATCH_DEFAULT_CLOCK)
 {
     struct timespec ts;
     clock_gettime(clock_type, &ts);
     return UInt64(ts.tv_sec * 1000000000LL + ts.tv_nsec);
 }
 
-/// Sometimes monotonic clock may not be monotonic (due to bug in kernel?).
-/// It may cause some operations to fail with "Timeout exceeded: elapsed 18446744073.709553 seconds".
 /// Takes previously returned value and returns it again if time stepped back for some reason.
-inline UInt64 clock_gettime_ns_adjusted(UInt64 prev_time, clockid_t clock_type = CLOCK_MONOTONIC)
+///
+/// You should use this if OS does not support CLOCK_MONOTONIC_RAW
+inline UInt64 clock_gettime_ns_adjusted(UInt64 prev_time, clockid_t clock_type = STOPWATCH_DEFAULT_CLOCK)
 {
+#ifdef CLOCK_MONOTONIC_RAW
+    if (likely(clock_type == CLOCK_MONOTONIC_RAW))
+        return clock_gettime_ns(clock_type);
+#endif
+
     UInt64 current_time = clock_gettime_ns(clock_type);
     if (likely(prev_time <= current_time))
         return current_time;
@@ -36,10 +51,10 @@ inline UInt64 clock_gettime_ns_adjusted(UInt64 prev_time, clockid_t clock_type =
 class Stopwatch
 {
 public:
-    /** CLOCK_MONOTONIC works relatively efficient (~15 million calls/sec) and doesn't lead to syscall.
+    /** CLOCK_MONOTONIC/CLOCK_MONOTONIC_RAW works relatively efficient (~40-50 million calls/sec) and doesn't lead to syscall.
       * Pass CLOCK_MONOTONIC_COARSE, if you need better performance with acceptable cost of several milliseconds of inaccuracy.
       */
-    explicit Stopwatch(clockid_t clock_type_ = CLOCK_MONOTONIC) : clock_type(clock_type_) { start(); }
+    explicit Stopwatch(clockid_t clock_type_ = STOPWATCH_DEFAULT_CLOCK) : clock_type(clock_type_) { start(); }
     explicit Stopwatch(clockid_t clock_type_, UInt64 start_nanoseconds, bool is_running_)
         : start_ns(start_nanoseconds), clock_type(clock_type_), is_running(is_running_)
     {
@@ -75,7 +90,7 @@ using StopwatchUniquePtr = std::unique_ptr<Stopwatch>;
 class AtomicStopwatch
 {
 public:
-    explicit AtomicStopwatch(clockid_t clock_type_ = CLOCK_MONOTONIC) : clock_type(clock_type_) { restart(); }
+    explicit AtomicStopwatch(clockid_t clock_type_ = STOPWATCH_DEFAULT_CLOCK) : clock_type(clock_type_) { restart(); }
 
     void restart()                     { start_ns = nanoseconds(0); }
     UInt64 elapsed() const
