Make timer_t use microseconds and make it restartable

We can use the timer in more places if we have better resolution. For
places where we don't need the resolution it doesn't matter because it
will just get rounded. While we are at it we also use microseconds in
the thread_pool code so that we use the same unit everywhere.

The timer is restartable now, by repeatedly calling start/stop() we can
add up the times.

Also we are trying, as much as possible, to keep to the time types
supplied by chrono. This gives us automatic correct time output with the
fmt library which knows about those types. And it should make time
conversions easier.

Author: joto

src/flex-table.hpp

@@ -237,7 +237,7 @@ class table_connection_t
         return *m_proj;
     }
 
-    void task_set(std::future<std::chrono::milliseconds> &&future)
+    void task_set(std::future<std::chrono::microseconds> &&future)
     {
         m_task_result.set(std::move(future));
     }

src/middle-pgsql.hpp

@@ -122,12 +122,12 @@ struct middle_pgsql_t : public middle_t
         std::string m_prepare_fw_dep_lookups;
         std::string m_create_fw_dep_indexes;
 
-        void task_set(std::future<std::chrono::milliseconds> &&future)
+        void task_set(std::future<std::chrono::microseconds> &&future)
         {
             m_task_result.set(std::move(future));
         }
 
-        std::chrono::milliseconds task_wait() { return m_task_result.wait(); }
+        std::chrono::microseconds task_wait() { return m_task_result.wait(); }
 
     private:
         std::shared_ptr<db_target_descr_t> m_copy_target;

src/table.hpp

@@ -43,7 +43,7 @@ class table_t
 
     void sync();
 
-    void task_set(std::future<std::chrono::milliseconds> &&future)
+    void task_set(std::future<std::chrono::microseconds> &&future)
     {
         m_task_result.set(std::move(future));
     }

src/thread-pool.cpp

@@ -14,14 +14,14 @@
 #include <cassert>
 #include <string>
 
-std::chrono::milliseconds task_result_t::wait()
+std::chrono::microseconds task_result_t::wait()
 {
     if (m_future.valid()) {
         m_result = m_future.get();
 
         // Make sure the result is not 0 so it is different than
         // "no result yet".
-        if (m_result == std::chrono::milliseconds::zero()) {
+        if (m_result == std::chrono::microseconds::zero()) {
             ++m_result;
         }
     }

src/thread-pool.hpp

@@ -19,6 +19,7 @@
  */
 
 #include "logging.hpp"
+#include "util.hpp"
 
 #include <osmium/thread/function_wrapper.hpp>
 #include <osmium/thread/queue.hpp>
@@ -41,7 +42,7 @@ class task_result_t
      * Initialize this result with the future obtained from the
      * thread_pool_t::submit() function.
      */
-    void set(std::future<std::chrono::milliseconds> &&future)
+    void set(std::future<std::chrono::microseconds> &&future)
     {
         m_future = std::move(future);
     }
@@ -52,17 +53,17 @@ class task_result_t
      * \return The runtime of the task.
      * \throws Any exception the task has thrown.
      */
-    std::chrono::milliseconds wait();
+    std::chrono::microseconds wait();
 
     /**
      * Return the run-time of this task. Will be 0 if the task has not
      * yet finished or >0 if the task has finished.
      */
-    std::chrono::milliseconds runtime() const noexcept { return m_result; }
+    std::chrono::microseconds runtime() const noexcept { return m_result; }
 
 private:
-    std::future<std::chrono::milliseconds> m_future{};
-    std::chrono::milliseconds m_result{};
+    std::future<std::chrono::microseconds> m_future{};
+    std::chrono::microseconds m_result{};
 }; // class task_result_t
 
 /**
@@ -96,23 +97,21 @@ class thread_pool_t
      *         of the task can be queried.
      */
     template <typename TFunction>
-    std::future<std::chrono::milliseconds> submit(TFunction &&func)
+    std::future<std::chrono::microseconds> submit(TFunction &&func)
     {
-        std::packaged_task<std::chrono::milliseconds()> task{
+        std::packaged_task<std::chrono::microseconds()> task{
             [f = std::forward<TFunction>(func)]() {
                 log_debug("Starting task...");
-                auto const start_time = std::chrono::steady_clock::now();
+                util::timer_t timer;
                 f();
-                auto const end_time = std::chrono::steady_clock::now();
-                auto const run_time =
-                    std::chrono::duration_cast<std::chrono::milliseconds>(
-                        end_time - start_time);
+                timer.stop();
+                log_debug("Done task in {}.",
+                          std::chrono::duration_cast<std::chrono::milliseconds>(
+                              timer.elapsed()));
 
-                log_debug("Done task in {}.", run_time);
-
-                return run_time;
+                return timer.elapsed();
             }};
-        std::future<std::chrono::milliseconds> future_result{task.get_future()};
+        std::future<std::chrono::microseconds> future_result{task.get_future()};
         m_work_queue.push(std::move(task));
 
         return future_result;

src/util.cpp

@@ -48,10 +48,10 @@ std::string human_readable_duration(uint64_t seconds)
     return "{}s ({}h {}m {}s)"_format(seconds, mins / 60, mins % 60, secs);
 }
 
-std::string human_readable_duration(std::chrono::milliseconds ms)
+std::string human_readable_duration(std::chrono::microseconds duration)
 {
     return human_readable_duration(static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::seconds>(ms).count()));
+        std::chrono::duration_cast<std::chrono::seconds>(duration).count()));
 }
 
 std::string get_password()

src/util.hpp

@@ -83,26 +83,26 @@ class string_id_list_t
 }; // class string_id_list_t
 
 /**
- * Helper class for timing with a granularity of seconds. The timer will
- * start on construction and is stopped by calling stop().
+ * Helper class for timing with a granularity of microseconds. The timer will
+ * start on construction or it can be started by calling start(). It is stopped
+ * by calling stop(). Timer can be restarted and times will be added up.
  */
 class timer_t
 {
 public:
-    timer_t() noexcept : m_start(std::time(nullptr)) {}
+    timer_t() noexcept : m_start(clock::now()) {}
+
+    void start() noexcept { m_start = clock::now(); }
 
     /// Stop timer and return elapsed time
-    uint64_t stop() noexcept
+    std::chrono::microseconds stop() noexcept
     {
-        m_stop = std::time(nullptr);
-        return static_cast<uint64_t>(m_stop - m_start);
+        m_duration += std::chrono::duration_cast<std::chrono::microseconds>(
+            clock::now() - m_start);
+        return m_duration;
     }
 
-    /// Return elapsed time
-    uint64_t elapsed() const noexcept
-    {
-        return static_cast<uint64_t>(m_stop - m_start);
-    }
+    std::chrono::microseconds elapsed() const noexcept { return m_duration; }
 
     /**
      * Calculate ratio: value divided by elapsed time.
@@ -111,22 +111,25 @@ class timer_t
      */
     double per_second(double value) const noexcept
     {
-        auto const seconds = elapsed();
+        auto const seconds =
+            std::chrono::duration_cast<std::chrono::seconds>(m_duration)
+                .count();
         if (seconds == 0) {
             return 0.0;
         }
         return value / static_cast<double>(seconds);
     }
 
 private:
-    std::time_t m_start;
-    std::time_t m_stop = 0;
+    using clock = std::chrono::steady_clock;
+    std::chrono::time_point<clock> m_start;
+    std::chrono::microseconds m_duration{};
 
 }; // class timer_t
 
 std::string human_readable_duration(uint64_t seconds);
 
-std::string human_readable_duration(std::chrono::milliseconds ms);
+std::string human_readable_duration(std::chrono::microseconds duration);
 
 std::string get_password();