dunedaq::utilities::TimestampEstimator Class Reference

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

#include <TimestampEstimator.hpp>

Inheritance diagram for dunedaq::utilities::TimestampEstimator:

Collaboration diagram for dunedaq::utilities::TimestampEstimator:

Classes
struct	TimeSyncPoint

Public Member Functions
	TimestampEstimator (uint32_t run_number, uint64_t clock_frequency_hz)
	TimestampEstimator (uint64_t clock_frequency_hz)
virtual	~TimestampEstimator ()
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)
	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_timestamp (uint64_t ts, std::atomic< bool > &continue_flag)

Private Attributes
std::atomic< TimeSyncPoint >	m_current_timestamp_estimate
uint64_t	m_clock_frequency_hz
uint64_t	m_most_recent_daq_time
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 }

Detailed Description

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

Definition at line 27 of file TimestampEstimator.hpp.

Constructor & Destructor Documentation

TimestampEstimator() [1/2]

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

Definition at line 21 of file TimestampEstimator.cpp.

  : TimestampEstimator(clock_frequency_hz)
{
  m_run_number = run_number;
}

TimestampEstimator() [2/2]

dunedaq::utilities::TimestampEstimator::TimestampEstimator ( uint64_t clock_frequency_hz )

explicit

Definition at line 27 of file TimestampEstimator.cpp.

  : m_current_timestamp_estimate(
      TimeSyncPoint{ std::numeric_limits<uint64_t>::max(), std::chrono::time_point<std::chrono::steady_clock>() })
  , m_clock_frequency_hz(clock_frequency_hz)
  , m_most_recent_daq_time(0)
  , m_most_recent_system_time(0)
  , m_run_number(0)
  , m_received_timesync_count(0)
{
  m_current_process_id = static_cast<uint32_t>(getpid());
}

~TimestampEstimator()

dunedaq::utilities::TimestampEstimator::~TimestampEstimator ( )

virtual

Definition at line 39 of file TimestampEstimator.cpp.

{}

Member Function Documentation

add_timestamp_datapoint()

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

Definition at line 74 of file TimestampEstimator.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();
  int64_t diff = 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 == std::numeric_limits<uint64_t>::max() || 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 != std::numeric_limits<uint64_t>::max()) {
    // 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 > 1e6)
        ers::warning(LateTimeSync(ERS_HERE, delta_time));
 
      const uint64_t new_timestamp = m_most_recent_daq_time + delta_time * m_clock_frequency_hz / 1000000;
 
      // Don't ever decrease the timestamp; just wait until enough
      // time passes that we want to increase it
      if (estimate.daq_time == std::numeric_limits<uint64_t>::max() || 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::TimestampEstimator::get_received_timesync_count ( ) const

inline

Definition at line 45 of file TimestampEstimator.hpp.

{ return m_received_timesync_count.load(); }

get_timestamp_estimate()

uint64_t dunedaq::utilities::TimestampEstimator::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 std::numeric_limits<uint64_t>::max() if no valid timestamp is currently available

Implements dunedaq::utilities::TimestampEstimatorBase.

Definition at line 47 of file TimestampEstimator.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 == std::numeric_limits<uint64_t>::max()) {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;
 
  return new_timestamp;
}

get_wait_estimate()

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

overridevirtual

Implements dunedaq::utilities::TimestampEstimatorBase.

Definition at line 64 of file TimestampEstimator.cpp.

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

timesync_callback()

template<class T >

void dunedaq::utilities::TimestampEstimator::timesync_callback

(

const T &

tsync

)

Definition at line 7 of file TimestampEstimator.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::TimestampEstimator::m_clock_frequency_hz

private

Definition at line 56 of file TimestampEstimator.hpp.

m_current_process_id

uint32_t dunedaq::utilities::TimestampEstimator::m_current_process_id

private

Definition at line 62 of file TimestampEstimator.hpp.

m_current_timestamp_estimate

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

private

Definition at line 53 of file TimestampEstimator.hpp.

m_datapoint_mutex

std::mutex dunedaq::utilities::TimestampEstimator::m_datapoint_mutex

private

Definition at line 59 of file TimestampEstimator.hpp.

m_most_recent_daq_time

uint64_t dunedaq::utilities::TimestampEstimator::m_most_recent_daq_time

private

Definition at line 57 of file TimestampEstimator.hpp.

m_most_recent_system_time

uint64_t dunedaq::utilities::TimestampEstimator::m_most_recent_system_time

private

Definition at line 58 of file TimestampEstimator.hpp.

m_received_timesync_count

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

private

Definition at line 61 of file TimestampEstimator.hpp.

m_run_number

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

private

Definition at line 60 of file TimestampEstimator.hpp.

{0};

---

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

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