#2154: Use std::chrono for TimeType

JacobDomagala · JacobDomagala · commit 362f533bc3f1 · 2023-11-14T00:28:28.000+01:00
diff --git a/src/vt/elm/elm_lb_data.cc b/src/vt/elm/elm_lb_data.cc
@@ -69,7 +69,7 @@ void ElementLBData::stop(TimeType time) {
   auto const started = cur_time_started_;
   if (started) {
     cur_time_started_ = false;
-    addTime(total_time.seconds());
+    addTime(total_time.seconds().count());
   }
 
   vt_debug_print(
diff --git a/src/vt/elm/elm_lb_data.h b/src/vt/elm/elm_lb_data.h
@@ -125,7 +125,7 @@ struct ElementLBData {
 
 protected:
   bool cur_time_started_ = false;
-  TimeType cur_time_ = TimeType{0.0};
+  TimeType cur_time_ = TimeType{};
   PhaseType cur_phase_ = fst_lb_phase;
   std::unordered_map<PhaseType, LoadType> phase_timings_ = {};
   std::unordered_map<PhaseType, CommMapType> phase_comm_ = {};
diff --git a/src/vt/event/event_record.h b/src/vt/event/event_record.h
@@ -138,7 +138,7 @@ struct EventRecord {
 
 # if vt_check_enabled(diagnostics)
   /// the time this event record was created
-  TimeType creation_time_stamp_ = TimeType{0.};
+  TimeType creation_time_stamp_ = TimeType{};
 # endif
 };
 
diff --git a/src/vt/messaging/active.cc b/src/vt/messaging/active.cc
@@ -347,7 +347,7 @@ EventType ActiveMessenger::sendMsgMPI(
     {
       VT_ALLOW_MPI_CALLS;
       #if vt_check_enabled(trace_enabled)
-        auto tr_begin = TimeType{0.};
+        auto tr_begin = TimeType{};
         if (theConfig()->vt_trace_mpi) {
           tr_begin = vt::timing::getCurrentTime();
         }
@@ -579,7 +579,7 @@ std::tuple<EventType, int> ActiveMessenger::sendDataMPI(
     );
     {
       #if vt_check_enabled(trace_enabled)
-        auto tr_begin = TimeType{0.};
+        auto tr_begin = TimeType{};
         if (theConfig()->vt_trace_mpi) {
           tr_begin = vt::timing::getCurrentTime();
         }
@@ -769,7 +769,7 @@ void ActiveMessenger::recvDataDirect(
     );
 
     #if vt_check_enabled(trace_enabled)
-      auto tr_begin = TimeType{0.};
+      auto tr_begin = TimeType{};
       if (theConfig()->vt_trace_mpi) {
         tr_begin = vt::timing::getCurrentTime();
       }
@@ -1006,7 +1006,7 @@ bool ActiveMessenger::tryProcessIncomingActiveMsg() {
 
     {
       #if vt_check_enabled(trace_enabled)
-        auto tr_begin = TimeType{0.};
+        auto tr_begin = TimeType{};
         if (theConfig()->vt_trace_mpi) {
           tr_begin = vt::timing::getCurrentTime();
         }
diff --git a/src/vt/messaging/request_holder.h b/src/vt/messaging/request_holder.h
@@ -98,7 +98,7 @@ struct RequestHolder {
   bool testAll(Callable c, int& num_mpi_tests) {
 #   if vt_check_enabled(trace_enabled)
     std::size_t const holder_size_start = holder_.size();
-    auto tr_begin = TimeType{0.0};
+    auto tr_begin = TimeType{};
     if (theConfig()->vt_trace_irecv_polling) {
       tr_begin = vt::timing::getCurrentTime();
     }
diff --git a/src/vt/runtime/component/diagnostic.impl.h b/src/vt/runtime/component/diagnostic.impl.h
@@ -93,7 +93,7 @@ meter::Timer<T> Diagnostic::registerTimerT(
 ) {
   auto sum = registerDiagnostic<T>(
     key + " [sum]", desc, DiagnosticUpdate::Sum, unit,
-    DiagnosticTypeEnum::PerformanceDiagnostic, T{0}
+    DiagnosticTypeEnum::PerformanceDiagnostic, T{}
   );
   auto min = registerDiagnostic<T>(
     key + " [min]", desc, DiagnosticUpdate::Min, unit,
@@ -105,7 +105,7 @@ meter::Timer<T> Diagnostic::registerTimerT(
   );
   auto avg = registerDiagnostic<T>(
     key + " [avg]", desc, DiagnosticUpdate::Avg, unit,
-    DiagnosticTypeEnum::PerformanceDiagnostic, T{0}
+    DiagnosticTypeEnum::PerformanceDiagnostic, T{}
   );
   return meter::Timer<T>{sum, avg, max, min};
 }
diff --git a/src/vt/runtime/component/diagnostic_value.h b/src/vt/runtime/component/diagnostic_value.h
@@ -168,7 +168,7 @@ struct DiagnosticValueWrapper {
    *
    * \return the max value
    */
-  T max() const { return N_ == 0 ? T{0} : max_; }
+  T max() const { return N_ == 0 ? T{} : max_; }
 
   /**
    * \internal \brief Get sum of values (use after reduction)
@@ -182,7 +182,7 @@ struct DiagnosticValueWrapper {
    *
    * \return the min value
    */
-  T min() const { return N_ == 0 ? T{0} : min_; }
+  T min() const { return N_ == 0 ? T{} : min_; }
 
   /**
    * \internal \brief Get the arithmetic mean value (use after reduction)
@@ -237,7 +237,7 @@ struct DiagnosticValueWrapper {
    */
   T getComputedValue() const {
     if (N_ > 0) {
-      return value_ / N_;
+      return value_ / static_cast<const T>(N_);
     } else {
       return value_;
     }
diff --git a/src/vt/runtime/component/meter/timer.h b/src/vt/runtime/component/meter/timer.h
@@ -102,9 +102,9 @@ struct Timer : DiagnosticStatsPack<T> {
    * \brief Stop the timer and record the interval
    */
   void stop() {
-    if (start_time_ != TimeType{0.}) {
+    if (start_time_ != TimeType{}) {
       update(start_time_, timing::getCurrentTime());
-      start_time_ = TimeType{0.};
+      start_time_ = TimeType{};
     }
   }
 
@@ -116,7 +116,7 @@ struct Timer : DiagnosticStatsPack<T> {
   }
 
 private:
-  T start_time_ = T{0};
+  T start_time_ = T{};
 };
 
 }}}} /* end namespace vt::runtime::component::meter */
diff --git a/src/vt/scheduler/scheduler.h b/src/vt/scheduler/scheduler.h
@@ -178,7 +178,7 @@ struct Scheduler : runtime::component::Component<Scheduler> {
    *
    * \param[in] current_time current time
    */
-  void runProgress(bool msg_only = false, TimeType current_time = TimeType{0.0} );
+  void runProgress(bool msg_only = false, TimeType current_time = TimeType{} );
 
   /**
    * \brief Runs the scheduler until a condition is met.
@@ -438,7 +438,7 @@ struct Scheduler : runtime::component::Component<Scheduler> {
   EventTriggerContType event_triggers;
   EventTriggerContType event_triggers_once;
 
-  TimeType last_progress_time_ = TimeType{0.0};
+  TimeType last_progress_time_ = TimeType{};
   bool progress_time_enabled_ = false;
   int32_t processed_after_last_progress_ = 0;
 
diff --git a/src/vt/timetrigger/trigger.h b/src/vt/timetrigger/trigger.h
@@ -85,8 +85,7 @@ struct Trigger {
    * \return the next time this should be triggered
    */
   TimeType nextTriggerTime() const {
-    return TimeType{
-      (last_trigger_time_.milliseconds() + period_.count()) / 1000.0};
+    return TimeType{last_trigger_time_.milliseconds() + period_};
   }
 
   /**
@@ -142,7 +141,7 @@ struct Trigger {
 private:
   std::chrono::milliseconds period_;   /**< The trigger's period */
   ActionType trigger_ = nullptr;       /**< The action to trigger  */
-  TimeType last_trigger_time_ = TimeType{0.};    /**< The last time it was triggered */
+  TimeType last_trigger_time_ = TimeType{};    /**< The last time it was triggered */
   int id_ = -1;                        /**< The trigger's id */
 };
 
diff --git a/src/vt/timing/timing.h b/src/vt/timing/timing.h
@@ -75,7 +75,7 @@ struct formatter<::vt::TimeTypeWrapper> {
   auto format(::vt::TimeTypeWrapper const& t, FormatContext& ctx) {
     return fmt::format_to(
       ctx.out(), "{}",
-      to_engineering_string(t.seconds(), 3, eng_exponential, "s")
+      to_engineering_string(t.seconds().count(), 3, eng_exponential, "s")
     );
   }
 };
diff --git a/src/vt/timing/timing_type.h b/src/vt/timing/timing_type.h
@@ -44,18 +44,42 @@
 #if !defined INCLUDED_VT_TIMING_TIMING_TYPE_H
 #define INCLUDED_VT_TIMING_TIMING_TYPE_H
 
-#include <limits>
+#include <chrono>
 #include <algorithm>
 #include <cmath>
 
 namespace vt {
 
 struct TimeTypeWrapper {
   using TimeTypeInternal = double;
-  explicit constexpr TimeTypeWrapper(const TimeTypeInternal time = 0.0)
-    : time_(time) { }
 
-  explicit operator double() const { return time_; }
+  using Seconds = std::chrono::duration<TimeTypeInternal>;
+  using Milliseconds = std::chrono::duration<TimeTypeInternal, std::milli>;
+  using Microseconds = std::chrono::duration<TimeTypeInternal, std::micro>;
+
+  template <typename T>
+  explicit TimeTypeWrapper(
+    T time,
+    typename std::enable_if<
+      std::is_integral<T>::value || std::is_floating_point<T>::value>::type* =
+      nullptr)
+    : time_(Seconds(static_cast<TimeTypeInternal>(time))) { }
+
+  template <typename Rep = double>
+  explicit TimeTypeWrapper(
+    const std::chrono::duration<Rep, std::micro>& time =
+      std::chrono::duration<Rep, std::micro>(0))
+    : time_(std::chrono::duration_cast<Seconds>(time)) { }
+
+  template <typename Rep = double>
+  explicit TimeTypeWrapper(const std::chrono::duration<Rep, std::milli>& time)
+    : time_(std::chrono::duration_cast<Seconds>(time)) { }
+
+  template <typename Rep = double>
+  explicit TimeTypeWrapper(const Seconds& time)
+    : time_(std::chrono::duration_cast<Seconds>(time)) { }
+
+  explicit operator TimeTypeInternal() const { return time_.count(); }
 
   TimeTypeWrapper& operator+=(const TimeTypeWrapper& other) {
     time_ += other.time_;
@@ -67,14 +91,9 @@ struct TimeTypeWrapper {
     return *this;
   }
 
-  TimeTypeWrapper& operator*=(const double scalar) {
-    time_ *= scalar;
-    return *this;
-  }
-
-  TimeTypeWrapper& operator/=(const double scalar) {
-    time_ /= scalar;
-    return *this;
+  friend TimeTypeWrapper
+  operator/(const TimeTypeWrapper& lhs, const TimeTypeWrapper& rhs) {
+    return TimeTypeWrapper{lhs.time_ / rhs.time_};
   }
 
   friend TimeTypeWrapper
@@ -87,36 +106,6 @@ struct TimeTypeWrapper {
     return TimeTypeWrapper(lhs.time_ - rhs.time_);
   }
 
-  friend TimeTypeWrapper
-  operator*(const TimeTypeWrapper& lhs, const TimeTypeWrapper& rhs) {
-    return TimeTypeWrapper(lhs.time_ * rhs.time_);
-  }
-
-  friend TimeTypeWrapper
-  operator*(const TimeTypeWrapper& time, const double scalar) {
-    return TimeTypeWrapper(time.time_ * scalar);
-  }
-
-  friend TimeTypeWrapper
-  operator*(const double scalar, const TimeTypeWrapper& time) {
-    return TimeTypeWrapper(time.time_ * scalar);
-  }
-
-  friend TimeTypeWrapper
-  operator/(const double scalar, const TimeTypeWrapper& time) {
-    return TimeTypeWrapper(scalar / time.time_);
-  }
-
-  friend TimeTypeWrapper
-  operator/(const TimeTypeWrapper& time, const double scalar) {
-    return TimeTypeWrapper(time.time_ / scalar);
-  }
-
-  friend TimeTypeWrapper
-  operator/(const TimeTypeWrapper& lhs, const TimeTypeWrapper& rhs) {
-    return TimeTypeWrapper(lhs.time_ / rhs.time_);
-  }
-
   friend bool
   operator<(const TimeTypeWrapper& lhs, const TimeTypeWrapper& rhs) {
     return lhs.time_ < rhs.time_;
@@ -147,51 +136,34 @@ struct TimeTypeWrapper {
     return lhs.time_ != rhs.time_;
   }
 
-  friend TimeTypeWrapper sqrt(const TimeTypeWrapper& time) {
-    return TimeTypeWrapper{std::sqrt(time.time_)};
+  template <typename Rep = double>
+  std::chrono::duration<Rep> seconds() const {
+    return std::chrono::duration_cast<std::chrono::duration<Rep>>(time_);
   }
 
-  TimeTypeInternal seconds() const { return time_; }
-  TimeTypeInternal milliseconds() const { return time_ * 1000; }
-  TimeTypeInternal microseconds() const { return time_ * 1000000; }
+  template <typename Rep = double>
+  std::chrono::duration<Rep, std::milli> milliseconds() const {
+    return std::chrono::duration_cast<std::chrono::duration<Rep, std::milli>>(
+      time_);
+  }
+
+  template <typename Rep = double>
+  std::chrono::duration<Rep, std::micro> microseconds() const {
+    return std::chrono::duration_cast<std::chrono::duration<Rep, std::micro>>(
+      time_);
+  }
 
   template <typename Serializer>
   void serialize(Serializer& s) {
     s | time_;
   }
 
 private:
-  TimeTypeInternal time_;
+  std::chrono::duration<double> time_;
 };
 
 using TimeType = TimeTypeWrapper;
 
 } /* end namespace vt */
 
-namespace std {
-template <>
-class numeric_limits<vt::TimeTypeWrapper> {
-  using Type = typename vt::TimeTypeWrapper::TimeTypeInternal;
-
-public:
-  static constexpr vt::TimeTypeWrapper max() noexcept {
-    return vt::TimeTypeWrapper(std::numeric_limits<Type>::max());
-  }
-
-  static constexpr vt::TimeTypeWrapper lowest() noexcept {
-    return vt::TimeTypeWrapper(std::numeric_limits<Type>::lowest());
-  }
-
-  inline vt::TimeTypeWrapper
-  min(const vt::TimeTypeWrapper& lhs, const vt::TimeTypeWrapper& rhs) {
-    return vt::TimeTypeWrapper(std::min(lhs.seconds(), rhs.seconds()));
-  }
-
-  inline vt::TimeTypeWrapper
-  max(const vt::TimeTypeWrapper& lhs, const vt::TimeTypeWrapper& rhs) {
-    return vt::TimeTypeWrapper(std::max(lhs.seconds(), rhs.seconds()));
-  }
-};
-} // namespace std
-
-#endif /*INCLUDED_VT_TIMING_TIMING_TYPE_H*/
+#endif // INCLUDED_VT_TIMING_TIMING_TYPE_H
diff --git a/src/vt/trace/trace_lite.h b/src/vt/trace/trace_lite.h
@@ -249,7 +249,7 @@ struct TraceLite  {
    * \return time in microsecond as integer
    */
   static inline TimeIntegerType timeToMicros(TimeType const time) {
-    return time.microseconds();
+    return time.microseconds().count();
   }
 
   /**
@@ -385,7 +385,7 @@ struct TraceLite  {
   TraceEventIDType cur_event_   = 1;
   UserEventIDType flush_event_  = no_user_event_id;
   bool enabled_                 = true;
-  TimeType start_time_          = TimeType{0.0};
+  TimeType start_time_          = TimeType{};
   std::string prog_name_        = "";
   std::string trace_name_       = "";
   std::string full_trace_name_  = "";
diff --git a/src/vt/trace/trace_log.h b/src/vt/trace/trace_log.h
@@ -351,10 +351,10 @@ struct Log final {
   // Excluding sys/user-specific data, expected ~24 bytes
 
   // Time of the event - all events need a time.
-  TimeType time = TimeType{0.0};
+  TimeType time = TimeType{};
   // If a duration can be expressed in a single event.
   // (Currently only for user-events.. could elim explicit end events.)
-  TimeType end_time = TimeType{0.0};
+  TimeType end_time = TimeType{};
 
   TraceConstantsType type = TraceConstantsType::InvalidTraceType;
   TraceEntryIDType ep = no_trace_entry_id;
diff --git a/src/vt/trace/trace_user.h b/src/vt/trace/trace_user.h
diff --git a/src/vt/vrt/collection/balance/baselb/baselb.h b/src/vt/vrt/collection/balance/baselb/baselb.h
diff --git a/src/vt/vrt/collection/balance/hierarchicallb/hierlb.cc b/src/vt/vrt/collection/balance/hierarchicallb/hierlb.cc
diff --git a/src/vt/vrt/collection/balance/hierarchicallb/hierlb.h b/src/vt/vrt/collection/balance/hierarchicallb/hierlb.h
diff --git a/tests/unit/scheduler/test_scheduler_progress.extended.cc b/tests/unit/scheduler/test_scheduler_progress.extended.cc
diff --git a/tests/unit/scheduler/test_scheduler_timings.cc b/tests/unit/scheduler/test_scheduler_timings.cc
diff --git a/tests/unit/timetrigger/test_time_trigger.extended.cc b/tests/unit/timetrigger/test_time_trigger.extended.cc

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ void ElementLBData::stop(TimeType time) {`
`69`	`69`	`auto const started = cur_time_started_;`
`70`	`70`	`if (started) {`
`71`	`71`	`cur_time_started_ = false;`
`72`		`- addTime(total_time.seconds());`
	`72`	`+ addTime(total_time.seconds().count());`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`vt_debug_print(`
Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ EventType ActiveMessenger::sendMsgMPI(`
`347`	`347`	`{`
`348`	`348`	`VT_ALLOW_MPI_CALLS;`
`349`	`349`	`#if vt_check_enabled(trace_enabled)`
`350`		`- auto tr_begin = TimeType{0.};`
	`350`	`+ auto tr_begin = TimeType{};`
`351`	`351`	`if (theConfig()->vt_trace_mpi) {`
`352`	`352`	`tr_begin = vt::timing::getCurrentTime();`
`353`	`353`	`}`
`@@ -579,7 +579,7 @@ std::tuple<EventType, int> ActiveMessenger::sendDataMPI(`
`579`	`579`	`);`
`580`	`580`	`{`
`581`	`581`	`#if vt_check_enabled(trace_enabled)`
`582`		`- auto tr_begin = TimeType{0.};`
	`582`	`+ auto tr_begin = TimeType{};`
`583`	`583`	`if (theConfig()->vt_trace_mpi) {`
`584`	`584`	`tr_begin = vt::timing::getCurrentTime();`
`585`	`585`	`}`
`@@ -769,7 +769,7 @@ void ActiveMessenger::recvDataDirect(`
`769`	`769`	`);`
`770`	`770`
`771`	`771`	`#if vt_check_enabled(trace_enabled)`
`772`		`- auto tr_begin = TimeType{0.};`
	`772`	`+ auto tr_begin = TimeType{};`
`773`	`773`	`if (theConfig()->vt_trace_mpi) {`
`774`	`774`	`tr_begin = vt::timing::getCurrentTime();`
`775`	`775`	`}`
`@@ -1006,7 +1006,7 @@ bool ActiveMessenger::tryProcessIncomingActiveMsg() {`
`1006`	`1006`
`1007`	`1007`	`{`
`1008`	`1008`	`#if vt_check_enabled(trace_enabled)`
`1009`		`- auto tr_begin = TimeType{0.};`
	`1009`	`+ auto tr_begin = TimeType{};`
`1010`	`1010`	`if (theConfig()->vt_trace_mpi) {`
`1011`	`1011`	`tr_begin = vt::timing::getCurrentTime();`
`1012`	`1012`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ struct RequestHolder {`
`98`	`98`	`bool testAll(Callable c, int& num_mpi_tests) {`
`99`	`99`	`# if vt_check_enabled(trace_enabled)`
`100`	`100`	`std::size_t const holder_size_start = holder_.size();`
`101`		`- auto tr_begin = TimeType{0.0};`
	`101`	`+ auto tr_begin = TimeType{};`
`102`	`102`	`if (theConfig()->vt_trace_irecv_polling) {`
`103`	`103`	`tr_begin = vt::timing::getCurrentTime();`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,9 +102,9 @@ struct Timer : DiagnosticStatsPack<T> {`
`102`	`102`	`* \brief Stop the timer and record the interval`
`103`	`103`	`*/`
`104`	`104`	`void stop() {`
`105`		`- if (start_time_ != TimeType{0.}) {`
	`105`	`+ if (start_time_ != TimeType{}) {`
`106`	`106`	`update(start_time_, timing::getCurrentTime());`
`107`		`- start_time_ = TimeType{0.};`
	`107`	`+ start_time_ = TimeType{};`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`@@ -116,7 +116,7 @@ struct Timer : DiagnosticStatsPack<T> {`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`private:`
`119`		`- T start_time_ = T{0};`
	`119`	`+ T start_time_ = T{};`
`120`	`120`	`};`
`121`	`121`
`122`	`122`	`}}}} /* end namespace vt::runtime::component::meter */`