Merge pull request #1829 from joto/make-timer-finer

Make timer_t use microseconds and make it restartable

Author: lonvia

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();