core: use steady_clock where monotonic clock is required

Use steady_clock instead of high_resolution_clock where monotonic
clock is required. high_resolution_clock is essentially a
system_clock (Wall Clock) therefore may not be assumed monotonic
since Wall Clock may move backwards due to time/date adjustments.

Signed-off-by: Vlad Zolotarov <[email protected]>

apps/memcached/memcache.cc

@@ -82,6 +82,16 @@ struct expiration {
         } else if (s <= seconds_in_a_month) {
             _time = clock_type::now() + seconds(s); // from delta
         } else {
+            //
+            // seastar::reactor supports only a monotonic clock at the moment
+            // therefore this may make the elements with the absolute expiration
+            // time expire at the wrong time if the wall clock has been updated
+            // during the expiration period. However the original memcached has
+            // the same weakness.
+            //
+            // TODO: Fix this when a support for system_clock-based timers is
+            // added to the seastar::reactor.
+            //
             _time = time_point(seconds(s + wc_to_clock_type_delta)); // from real time
         }
     }

apps/seawreck/seawreck.cc

@@ -189,7 +189,7 @@ int main(int ac, char** av) {
         auto http_clients = new distributed<http_client>;
 
         // Start http requests on all the cores
-        auto started = std::chrono::high_resolution_clock::now();
+        auto started = std::chrono::steady_clock::now();
         print("========== http_client ============\n");
         print("Server: %s\n", server);
         print("Connections: %u\n", total_conn);
@@ -202,7 +202,7 @@ int main(int ac, char** av) {
             return http_clients->map_reduce(adder<uint64_t>(), &http_client::total_reqs);
         }).then([http_clients, started] (auto total_reqs) {
            // All the http requests are finished
-           auto finished = std::chrono::high_resolution_clock::now();
+           auto finished = std::chrono::steady_clock::now();
            auto elapsed = finished - started;
            auto secs = static_cast<double>(elapsed.count() / 1000000000.0);
            print("Total cpus: %u\n", smp::count);

core/reactor.cc

@@ -235,7 +235,7 @@ reactor::reactor()
     sev.sigev_notify = SIGEV_THREAD_ID;
     sev._sigev_un._tid = syscall(SYS_gettid);
     sev.sigev_signo = alarm_signal();
-    r = timer_create(CLOCK_REALTIME, &sev, &_timer);
+    r = timer_create(CLOCK_MONOTONIC, &sev, &_timer);
     assert(r >= 0);
     sev.sigev_signo = task_quota_signal();
     r = timer_create(CLOCK_THREAD_CPUTIME_ID, &sev, &_task_quota_timer);
@@ -1584,10 +1584,10 @@ int reactor::run() {
 
     using namespace std::chrono_literals;
     timer<lowres_clock> load_timer;
-    std::chrono::high_resolution_clock::rep idle_count = 0;
-    auto idle_start = std::chrono::high_resolution_clock::now(), idle_end = idle_start;
+    std::chrono::steady_clock::rep idle_count = 0;
+    auto idle_start = std::chrono::steady_clock::now(), idle_end = idle_start;
     load_timer.set_callback([this, &idle_count, &idle_start, &idle_end] () mutable {
-        auto load = double(idle_count + (idle_end - idle_start).count()) / double(std::chrono::duration_cast<std::chrono::high_resolution_clock::duration>(1s).count());
+        auto load = double(idle_count + (idle_end - idle_start).count()) / double(std::chrono::duration_cast<std::chrono::steady_clock::duration>(1s).count());
         load = std::min(load, 1.0);
         idle_count = 0;
         idle_start = idle_end;
@@ -1636,7 +1636,7 @@ int reactor::run() {
         }
 
         if (!poll_once() && _pending_tasks.empty()) {
-            idle_end = std::chrono::high_resolution_clock::now();
+            idle_end = std::chrono::steady_clock::now();
             if (!idle) {
                 idle_start = idle_end;
                 idle = true;
@@ -1645,7 +1645,7 @@ int reactor::run() {
             if (idle_end - idle_start > _max_poll_time) {
                 sleep();
                 // We may have slept for a while, so freshen idle_end
-                idle_end = std::chrono::high_resolution_clock::now();
+                idle_end = std::chrono::steady_clock::now();
             }
         } else {
             if (idle) {

core/scollectd.cc

@@ -54,7 +54,7 @@ bool scollectd::type_instance_id::operator==(
 namespace scollectd {
 
 using namespace std::chrono_literals;
-using clock_type = std::chrono::high_resolution_clock;
+using clock_type = std::chrono::steady_clock;
 
 
 static const ipv4_addr default_addr("239.192.74.66:25826");
@@ -353,7 +353,7 @@ class impl {
         };
         // append as many values as we can fit into a packet (1024 bytes)
         auto send_packet = [this, ctxt]() {
-            auto start = std::chrono::high_resolution_clock::now();
+            auto start = std::chrono::steady_clock::now();
             auto & i = std::get<iterator>(*ctxt);
             auto & out = std::get<cpwriter>(*ctxt);
 
@@ -378,7 +378,7 @@ class impl {
             }
             return _chan.send(_addr, net::packet(out.data(), out.size())).then([start, ctxt, this]() {
                         auto & out = std::get<cpwriter>(*ctxt);
-                        auto now = std::chrono::high_resolution_clock::now();
+                        auto now = std::chrono::steady_clock::now();
                         // dogfood stats
                         ++_num_packets;
                         _millis += std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();

core/sleep.hh

@@ -29,7 +29,7 @@
 #include "core/reactor.hh"
 #include "core/future.hh"
 
-template <typename Clock = std::chrono::high_resolution_clock, typename Rep, typename Period>
+template <typename Clock = std::chrono::steady_clock, typename Rep, typename Period>
 future<> sleep(std::chrono::duration<Rep, Period> dur) {
     struct sleeper {
         promise<> done;

core/thread.hh

@@ -76,7 +76,7 @@ class thread_attributes;
 class thread_scheduling_group;
 
 /// Clock used for scheduling threads
-using thread_clock = std::chrono::high_resolution_clock; // FIXME: tsc-based clock?
+using thread_clock = std::chrono::steady_clock;
 
 /// \cond internal
 class thread_context;

core/timer.hh

@@ -26,9 +26,9 @@
 #include "future.hh"
 #include "timer-set.hh"
 
-using clock_type = std::chrono::high_resolution_clock;
+using clock_type = std::chrono::steady_clock;
 
-template <typename Clock = std::chrono::high_resolution_clock>
+template <typename Clock = std::chrono::steady_clock>
 class timer {
 public:
     typedef typename Clock::time_point time_point;

tests/allocator_test.cc

@@ -124,7 +124,7 @@ int main(int ac, char** av) {
         }
     } else {
         auto time = vm["time"].as<float>();
-        using clock = std::chrono::high_resolution_clock;
+        using clock = std::chrono::steady_clock;
         auto end = clock::now() + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1) * time);
         while (clock::now() < end) {
             for (unsigned i = 0; i < 1000; ++i) {

tests/timertest.cc

@@ -88,7 +88,7 @@ struct timer_test {
 
 int main(int ac, char** av) {
     app_template app;
-    timer_test<std::chrono::high_resolution_clock> t1;
+    timer_test<std::chrono::steady_clock> t1;
     timer_test<lowres_clock> t2;
     return app.run_deprecated(ac, av, [&t1, &t2] {
         print("=== Start High res clock test\n");