evgen::details::TimeInUnitsBase< Clock, Unit > Class Template Reference

Class reading a Clock and converting the value to a specific Unit. More...

Public Types
using	duration_t = art::TimeValue_t
	Type of the time duration as returned by this class. More...

Public Member Functions
duration_t	operator() ()
	Reads and returns the current time the clock. More...

Static Public Member Functions
static duration_t	read_clock ()
	Reads and returns the current time the clock. More...
static duration_t	currentOffsetFromEpoch ()

Static Protected Member Functions
template<typename TimeInterval >
static constexpr duration_t	toDuration (TimeInterval dt)
	Converts a std::chrono::duration into our duration metric. More...
template<typename Rep , typename Period >
static constexpr auto	periodToDuration ()
	Returns the duration (duration_t) of a period type. More...
template<typename TimePoint >
static duration_t	timeFromEpoch (TimePoint t)
	Returns the time elapsed from the epoch to t. More...

Detailed Description

template<typename Clock, typename Unit>
class evgen::details::TimeInUnitsBase< Clock, Unit >

Class reading a Clock and converting the value to a specific Unit.

Definition at line 106 of file GeneratedEventTimestamp_plugin.cc.

Member Typedef Documentation

template<typename Clock, typename Unit>

using evgen::details::TimeInUnitsBase< Clock, Unit >::duration_t = art::TimeValue_t

Type of the time duration as returned by this class.

Definition at line 110 of file GeneratedEventTimestamp_plugin.cc.

Member Function Documentation

template<typename Clock , typename Duration >

auto evgen::details::TimeInUnitsBase< Clock, Duration >::currentOffsetFromEpoch ( )

static

Computes an approximation of the offset of the current time from the epoch.

Definition at line 146 of file GeneratedEventTimestamp_plugin.cc.

References evgen::details::Average< T >::average(), den, evgen::details::discretize(), evgen::details::Average< T >::insert(), and MF_LOG_DEBUG.

    {
      /*
       * The plan is to compare the `Clock` we use with the system clock, which
       * is guaranteed by the C++20 standard to refer to a well defined absolute
       * time point (the UNIX epoch, January 1, 1970).
       * Chances are that the resolution of the system clock is not as good as
       * the one of `Clock`. If the difference between the two clocks is less
       * than a few seconds, we attribute the difference to chance and we don't
       * correct for it.
       * 
       * Otherwise, the same time (almost!) is taken from the two clocks, and
       * the difference in `Duration` units is used as a correction.
       * 
       */
      using clock_t = Clock;
      using system_clock_t = std::chrono::system_clock;
      using namespace std::chrono_literals;
      
      // no point in doing the exercise if we are already using the system clock
      if (std::is_same<clock_t, system_clock_t>()) {
        MF_LOG_DEBUG("GeneratedEventTimestamp")
          << "Using system clock for timestamp: no offset needed.";
        return static_cast<duration_t>(0);
      }
      
      auto clock_time = clock_t::now();
      auto sys_clock_time = system_clock_t::now();
      
      // if the system clock is close to our clock, of if it is ahead of it,
      // use no offset (the latter stems from the consideration that that the
      // two clocks are equivalent although they suffer from some jitter)
      if (
        (timeFromEpoch(sys_clock_time) - timeFromEpoch(clock_time))
          < toDuration(5s)
        )
      {
        MF_LOG_DEBUG("GeneratedEventTimestamp")
          << "Offset with system clock is small ("
            << (timeFromEpoch(sys_clock_time) - timeFromEpoch(clock_time))
            << ", " << timeFromEpoch(sys_clock_time)
            << " vs. " << timeFromEpoch(clock_time)
            << "): no offset needed."
          ;
        return static_cast<duration_t>(0);
      }
      
      //
      // pick the largest of the resolutions for the comparison
      //
      using clock_period_t = typename clock_t::period;
      using system_clock_period_t = system_clock_t::period;
      using largest_period_t = std::conditional_t<
        (
          clock_period_t::num * system_clock_period_t::den
          > system_clock_period_t::num * clock_period_t::den
        ),
        clock_period_t,
        system_clock_period_t
        >;
      // this is the period expressed in the Duration unit
      constexpr auto largest_period
        = periodToDuration<typename clock_t::rep, largest_period_t>();
      
      //
      // compare and round
      //
      constexpr unsigned int times = 10U; // average 10 samples
      Average<duration_t> offset;
      for (unsigned int i = 0; i < times; ++i) {
        
        offset.insert
          (timeFromEpoch(sys_clock_time) - timeFromEpoch(clock_time));
        clock_time     = clock_t::now();
        sys_clock_time = system_clock_t::now();
        
      } // for
      
      MF_LOG_DEBUG("GeneratedEventTimestamp")
        <<   "System clock period: "
          << periodToDuration<typename clock_t::rep, system_clock_period_t>()
        << "\nUser clock period:   "
          << periodToDuration<typename clock_t::rep, clock_period_t>()
        << "\nOffset:              " << offset.average()
          << " (rounded to: " << largest_period << ")"
        ;
      
      // round off the offset with one "largest period"
      return discretize(offset.average(), largest_period);
      
    } // TimeInUnitsBase<>::currentOffsetFromEpoch()

template<typename Clock, typename Unit>

duration_t evgen::details::TimeInUnitsBase< Clock, Unit >::operator() ( )

inline

Reads and returns the current time the clock.

Definition at line 113 of file GeneratedEventTimestamp_plugin.cc.

{ return read_clock(); }

template<typename Clock, typename Unit>

template<typename Rep , typename Period >

static constexpr auto evgen::details::TimeInUnitsBase< Clock, Unit >::periodToDuration ( )

inlinestaticprotected

Returns the duration (duration_t) of a period type.

Definition at line 134 of file GeneratedEventTimestamp_plugin.cc.

        { return toDuration(std::chrono::duration<Rep, Period>(1)); }

template<typename Clock, typename Unit>

static duration_t evgen::details::TimeInUnitsBase< Clock, Unit >::read_clock ( )

inlinestatic

Reads and returns the current time the clock.

Definition at line 116 of file GeneratedEventTimestamp_plugin.cc.

{ return timeFromEpoch(Clock::now()); }

template<typename Clock, typename Unit>

template<typename TimePoint >

static duration_t evgen::details::TimeInUnitsBase< Clock, Unit >::timeFromEpoch ( TimePoint  t )

inlinestaticprotected

Returns the time elapsed from the epoch to t.

Definition at line 139 of file GeneratedEventTimestamp_plugin.cc.

        { return toDuration(t.time_since_epoch()); }

template<typename Clock, typename Unit>

template<typename TimeInterval >

static constexpr duration_t evgen::details::TimeInUnitsBase< Clock, Unit >::toDuration ( TimeInterval  dt )

inlinestaticprotected

Converts a std::chrono::duration into our duration metric.

Definition at line 126 of file GeneratedEventTimestamp_plugin.cc.

        {
          return static_cast<duration_t>
            (std::chrono::duration_cast<Unit>(dt).count());
        }

---

The documentation for this class was generated from the following file:

• nurandom/RandomUtils/GeneratedEventTimestamp_plugin.cc