dunedaq::utilities::TimestampEstimatorTimeSync Class Reference

TimestampEstimatorTimeSync is an implementation of TimestampEstimatorBase that uses TimeSync messages from an input queue to estimate the current timestamp. More...

#include <TimestampEstimatorTimeSync.hpp>

Inheritance diagram for dunedaq::utilities::TimestampEstimatorTimeSync:

Collaboration diagram for dunedaq::utilities::TimestampEstimatorTimeSync:

Classes
struct	TimeSyncPoint

Public Member Functions
	TimestampEstimatorTimeSync (uint32_t run_number, uint64_t clock_frequency_hz)
	TimestampEstimatorTimeSync (uint64_t clock_frequency_hz)
virtual	~TimestampEstimatorTimeSync ()
uint64_t	get_timestamp_estimate () const override
	Returns the current timestamp estimate or a special value if no valid timestamp is available.
std::chrono::microseconds	get_wait_estimate (uint64_t ts) const override
void	add_timestamp_datapoint (uint64_t daq_time, uint64_t system_time)
template<class T >
void	timesync_callback (const T &tsync)
uint64_t	get_received_timesync_count () const
Public Member Functions inherited from dunedaq::utilities::TimestampEstimatorBase
virtual	~TimestampEstimatorBase ()=default
WaitStatus	wait_for_valid_timestamp (std::atomic< bool > &continue_flag)
WaitStatus	wait_for_valid_timestamp (std::atomic< bool > &continue_flag, uint64_t &last_seen_ts)
	Waits for a valid timestamp to become available. Returns a status value that indicates whether a valid timestamp is available or not.
WaitStatus	wait_for_requested_timestamp (uint64_t ts, std::atomic< bool > &continue_flag)
WaitStatus	wait_for_requested_timestamp (uint64_t ts, std::atomic< bool > &continue_flag, uint64_t &last_seen_ts)

Private Attributes
std::atomic< TimeSyncPoint >	m_current_timestamp_estimate
uint64_t	m_clock_frequency_hz
uint64_t	m_most_recent_daq_time { s_invalid_ts }
uint64_t	m_most_recent_system_time
std::mutex	m_datapoint_mutex
uint32_t	m_run_number { 0 }
std::atomic< uint64_t >	m_received_timesync_count
uint32_t	m_current_process_id

Additional Inherited Members
Public Types inherited from dunedaq::utilities::TimestampEstimatorBase
enum	WaitStatus { kFinished , kInterrupted }
Static Public Attributes inherited from dunedaq::utilities::TimestampEstimatorBase
static constexpr uint64_t	s_invalid_ts = std::numeric_limits<uint64_t>::max()

Detailed Description

TimestampEstimatorTimeSync is an implementation of TimestampEstimatorBase that uses TimeSync messages from an input queue to estimate the current timestamp.

Definition at line 36 of file TimestampEstimatorTimeSync.hpp.

Constructor & Destructor Documentation

TimestampEstimatorTimeSync() [1/2]

dunedaq::utilities::TimestampEstimatorTimeSync::TimestampEstimatorTimeSync	(	uint32_t	run_number,
		uint64_t	clock_frequency_hz )

Definition at line 21 of file TimestampEstimatorTimeSync.cpp.

  : TimestampEstimatorTimeSync(clock_frequency_hz)
{
  m_run_number = run_number;
}

TimestampEstimatorTimeSync() [2/2]

dunedaq::utilities::TimestampEstimatorTimeSync::TimestampEstimatorTimeSync ( uint64_t clock_frequency_hz )

explicit

Definition at line 28 of file TimestampEstimatorTimeSync.cpp.

  : m_current_timestamp_estimate(TimeSyncPoint{ s_invalid_ts, std::chrono::time_point<std::chrono::steady_clock>() })
  , m_clock_frequency_hz(clock_frequency_hz)
  , m_most_recent_daq_time(s_invalid_ts)
  , m_most_recent_system_time(0)
  , m_run_number(0)
  , m_received_timesync_count(0)
{
  m_current_process_id = static_cast<uint32_t>(getpid()); // NOLINT(build/unsigned)
}

~TimestampEstimatorTimeSync()

dunedaq::utilities::TimestampEstimatorTimeSync::~TimestampEstimatorTimeSync ( )

virtual

Definition at line 39 of file TimestampEstimatorTimeSync.cpp.

{}

Member Function Documentation

add_timestamp_datapoint()

void dunedaq::utilities::TimestampEstimatorTimeSync::add_timestamp_datapoint	(	uint64_t	daq_time,
		uint64_t	system_time )

Definition at line 77 of file TimestampEstimatorTimeSync.cpp.

{
  using namespace std::chrono;
 
  std::scoped_lock<std::mutex> lk(m_datapoint_mutex);
 
  // First, update the latest timestamp
  TimeSyncPoint estimate = m_current_timestamp_estimate.load();
  auto diff = static_cast<int64_t>(estimate.daq_time - daq_time);
  TLOG_DEBUG(TLVL_TIME_SYNC_PROPERTIES) << "Got a TimeSync timestamp = " << daq_time
                                        << ", system time = " << system_time << " when current timestamp estimate was "
                                        << estimate.daq_time << ". diff=" << diff;
 
  if (m_most_recent_daq_time == s_invalid_ts || daq_time > m_most_recent_daq_time) {
    m_most_recent_daq_time = daq_time;
    m_most_recent_system_time = system_time;
  }
 
  if (m_most_recent_daq_time != s_invalid_ts) {
    // Update the current timestamp estimate, based on the most recently-read TimeSync
    using namespace std::chrono;
 
    auto time_now =
      static_cast<uint64_t>(duration_cast<microseconds>(system_clock::now().time_since_epoch()).count()); // NOLINT
    auto steady_time_now = steady_clock::now();
 
    // (PAR 2021-07-22) We only want to _increase_ our timestamp
    // estimate, not _decrease_ it, so we only attempt the update if
    // our system time is later than the latest time sync's system
    // time. We can get TimeSync messages from the "future" if
    // they're coming from another host whose clock is not exactly
    // synchronized with ours: that's fine, but if the discrepancy
    // is large, then badness could happen, so emit a warning
 
    if (time_now < m_most_recent_system_time - 10000) {
      ers::warning(EarlyTimeSync(ERS_HERE, m_most_recent_system_time - time_now));
    }
 
    if (time_now > m_most_recent_system_time) {
 
      auto delta_time = time_now - m_most_recent_system_time;
      TLOG_DEBUG(TLVL_TIME_SYNC_PROPERTIES)
        << "Time diff between current system and latest TimeSync system time [us]: " << delta_time;
 
      // Warn user if current system time is more than 1s ahead of latest TimeSync system time. This could be a sign of
      // an issue, e.g. machine times out of sync
      if (delta_time > 1'000'000)
        ers::warning(LateTimeSync(ERS_HERE, delta_time));
 
      const uint64_t new_timestamp = m_most_recent_daq_time + delta_time * m_clock_frequency_hz / 1000000; // NOLINT
 
      // Don't ever decrease the timestamp; just wait until enough
      // time passes that we want to increase it
      if (estimate.daq_time == s_invalid_ts || new_timestamp >= estimate.daq_time) {
        TLOG_DEBUG(TLVL_TIME_SYNC_NEW_ESTIMATE)
          << "Storing new timestamp estimate of " << new_timestamp << " ticks (..." << std::fixed
          << std::setprecision(8)
          << (static_cast<double>(new_timestamp % (m_clock_frequency_hz * 1000)) /
              static_cast<double>(m_clock_frequency_hz))
          << " sec), mrt.daq_time is " << m_most_recent_daq_time << " ticks (..."
          << (static_cast<double>(m_most_recent_daq_time % (m_clock_frequency_hz * 1000)) /
              static_cast<double>(m_clock_frequency_hz))
          << " sec), delta_time is " << delta_time << " usec, clock_freq is " << m_clock_frequency_hz << " Hz";
        m_current_timestamp_estimate.store(TimeSyncPoint{ new_timestamp, steady_time_now });
      } else {
        TLOG_DEBUG(TLVL_TIME_SYNC_NOTES) << "Not updating timestamp estimate backwards from "
                                         << m_current_timestamp_estimate.load().daq_time << " to " << new_timestamp;
      }
    }
  }
}

get_received_timesync_count()

uint64_t dunedaq::utilities::TimestampEstimatorTimeSync::get_received_timesync_count ( ) const

inline

Definition at line 54 of file TimestampEstimatorTimeSync.hpp.

{ return m_received_timesync_count.load(); } // NOLINT(build/unsigned)

get_timestamp_estimate()

uint64_t dunedaq::utilities::TimestampEstimatorTimeSync::get_timestamp_estimate ( ) const

overridevirtual

Returns the current timestamp estimate or a special value if no valid timestamp is available.

Returns

the current estimated timestamp (in units of DUNE Timing System ticks) or s_invalid_ts if no valid timestamp is currently available

Implements dunedaq::utilities::TimestampEstimatorBase.

Definition at line 47 of file TimestampEstimatorTimeSync.cpp.

{
  using namespace std::chrono;
 
  TimeSyncPoint estimate = m_current_timestamp_estimate.load();
  // 27-May-2025, KAB: added check if a valid timestamp is available and, if not, return early
  // with the special value that indicates that none is available.
  if (estimate.daq_time == s_invalid_ts) {
    return estimate.daq_time;
  }
 
  auto delta_time_us = duration_cast<microseconds>(steady_clock::now() - estimate.system_time).count();
 
  const uint64_t new_timestamp = estimate.daq_time + delta_time_us * m_clock_frequency_hz / 1000000; // NOLINT
 
  return new_timestamp;
}

get_wait_estimate()

std::chrono::microseconds dunedaq::utilities::TimestampEstimatorTimeSync::get_wait_estimate ( uint64_t ts ) const

overridevirtual

Implements dunedaq::utilities::TimestampEstimatorBase.

Definition at line 66 of file TimestampEstimatorTimeSync.cpp.

{
  auto now = get_timestamp_estimate();
  if (now > ts)
    return std::chrono::microseconds(0);
  auto diff = ts - now;
  return std::chrono::microseconds(static_cast<std::chrono::microseconds::rep>(
    static_cast<double>(diff) * 1000000. / static_cast<double>(m_clock_frequency_hz)));
}

timesync_callback()

template<class T >

void dunedaq::utilities::TimestampEstimatorTimeSync::timesync_callback

(

const T &

tsync

)

Definition at line 7 of file TimestampEstimatorTimeSync.hxx.

{
  ++m_received_timesync_count;
  TLOG_DEBUG(TLVL_TIME_SYNC_PROPERTIES) << "Got a TimeSync run=" << tsync.run_number << " local run=" << m_run_number
                                        << " seqno=" << tsync.sequence_number << " source_pid=" << tsync.source_pid;
  if (tsync.run_number == m_run_number && tsync.source_pid != m_current_process_id) {
    add_timestamp_datapoint(tsync.daq_time, tsync.system_time);
  } else {
    TLOG_DEBUG(0) << "Discarded TimeSync message from run " << tsync.run_number << " during run " << m_run_number
                  << " with pid " << tsync.source_pid << " and timestamp " << tsync.daq_time;
  }
}

Member Data Documentation

m_clock_frequency_hz

uint64_t dunedaq::utilities::TimestampEstimatorTimeSync::m_clock_frequency_hz

private

Definition at line 65 of file TimestampEstimatorTimeSync.hpp.

m_current_process_id

uint32_t dunedaq::utilities::TimestampEstimatorTimeSync::m_current_process_id

private

Definition at line 71 of file TimestampEstimatorTimeSync.hpp.

m_current_timestamp_estimate

std::atomic<TimeSyncPoint> dunedaq::utilities::TimestampEstimatorTimeSync::m_current_timestamp_estimate

private

Definition at line 63 of file TimestampEstimatorTimeSync.hpp.

m_datapoint_mutex

std::mutex dunedaq::utilities::TimestampEstimatorTimeSync::m_datapoint_mutex

private

Definition at line 68 of file TimestampEstimatorTimeSync.hpp.

m_most_recent_daq_time

uint64_t dunedaq::utilities::TimestampEstimatorTimeSync::m_most_recent_daq_time { s_invalid_ts }

private

Definition at line 66 of file TimestampEstimatorTimeSync.hpp.

{ s_invalid_ts }; // NOLINT(build/unsigned)

m_most_recent_system_time

uint64_t dunedaq::utilities::TimestampEstimatorTimeSync::m_most_recent_system_time

private

Definition at line 67 of file TimestampEstimatorTimeSync.hpp.

m_received_timesync_count

std::atomic<uint64_t> dunedaq::utilities::TimestampEstimatorTimeSync::m_received_timesync_count

private

Definition at line 70 of file TimestampEstimatorTimeSync.hpp.

m_run_number

uint32_t dunedaq::utilities::TimestampEstimatorTimeSync::m_run_number { 0 }

private

Definition at line 69 of file TimestampEstimatorTimeSync.hpp.

{ 0 };                      // NOLINT(build/unsigned)

---

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

• /github/workspace/dunedaq/sourcecode/utilities/include/utilities/TimestampEstimatorTimeSync.hpp
• /github/workspace/dunedaq/sourcecode/utilities/include/utilities/detail/TimestampEstimatorTimeSync.hxx
• /github/workspace/dunedaq/sourcecode/utilities/src/TimestampEstimatorTimeSync.cpp