dunedaq::trigger::Latency Class Reference

#include <Latency.hpp>

Public Types
enum class	TimeUnit { Microseconds = 1 , Milliseconds = 2 }

Public Member Functions
	Latency (TimeUnit time_unit=TimeUnit::Microseconds)
	~Latency ()
void	update_latency_in (uint64_t latency)
void	update_latency_out (uint64_t latency)
latency	get_latency_in () const
latency	get_latency_out () const

Private Types
using	latency = uint64_t

Private Member Functions
void	setup_conversion ()
uint64_t	get_current_system_time () const
void	update_single_latency (uint64_t latency, std::atomic< uint64_t > &latency_atomic)

Private Attributes
std::atomic< latency >	m_latency_in
std::atomic< latency >	m_latency_out
TimeUnit	m_time_unit
double	m_clock_ticks_conversion
std::function< uint64_t()>	m_get_current_time

Detailed Description

Definition at line 22 of file Latency.hpp.

Member Typedef Documentation

latency

using dunedaq::trigger::Latency::latency = uint64_t

private

Definition at line 23 of file Latency.hpp.

Member Enumeration Documentation

TimeUnit

enum class dunedaq::trigger::Latency::TimeUnit

strong

Enumerator
Microseconds
Milliseconds

Definition at line 27 of file Latency.hpp.

{ Microseconds = 1, Milliseconds = 2 };

Constructor & Destructor Documentation

Latency()

dunedaq::trigger::Latency::Latency ( TimeUnit time_unit = TimeUnit::Microseconds )

inline

Definition at line 30 of file Latency.hpp.

              : m_latency_in(0), m_latency_out(0), m_time_unit(time_unit) {
              setup_conversion();
          }

~Latency()

dunedaq::trigger::Latency::~Latency ( )

inline

Definition at line 35 of file Latency.hpp.

{}

Member Function Documentation

get_current_system_time()

uint64_t dunedaq::trigger::Latency::get_current_system_time ( ) const

inlineprivate

Definition at line 76 of file Latency.hpp.

                                                   {
              return m_get_current_time();
          }

get_latency_in()

latency dunedaq::trigger::Latency::get_latency_in ( ) const

inline

Definition at line 48 of file Latency.hpp.

                                         {
              return m_latency_in.load();
          }

get_latency_out()

latency dunedaq::trigger::Latency::get_latency_out ( ) const

inline

Definition at line 53 of file Latency.hpp.

                                          {
              return m_latency_out.load();
          }

setup_conversion()

void dunedaq::trigger::Latency::setup_conversion ( )

inlineprivate

Definition at line 59 of file Latency.hpp.

                                  {
              if (m_time_unit == TimeUnit::Microseconds) {
                  m_clock_ticks_conversion = 16 * 1e-3; // Conversion for microseconds
                  m_get_current_time = []() {
                      return std::chrono::duration_cast<std::chrono::microseconds>(
                          std::chrono::system_clock::now().time_since_epoch()).count();
                  };
              } else {
                  m_clock_ticks_conversion = 16 * 1e-6; // Conversion for milliseconds
                  m_get_current_time = []() {
                      return std::chrono::duration_cast<std::chrono::milliseconds>(
                          std::chrono::system_clock::now().time_since_epoch()).count();
                  };
              }
          }

update_latency_in()

void dunedaq::trigger::Latency::update_latency_in ( uint64_t latency )

inline

Definition at line 38 of file Latency.hpp.

                                                   {
              update_single_latency(latency, m_latency_in);
          }

update_latency_out()

void dunedaq::trigger::Latency::update_latency_out ( uint64_t latency )

inline

Definition at line 43 of file Latency.hpp.

                                                    {
              update_single_latency(latency, m_latency_out);
          }

update_single_latency()

void dunedaq::trigger::Latency::update_single_latency ( uint64_t latency, std::atomic< uint64_t > & latency_atomic )

inlineprivate

Definition at line 81 of file Latency.hpp.

                                                                                            {
              uint64_t current_time = get_current_system_time();
              uint64_t latency_time = latency * m_clock_ticks_conversion;
              uint64_t diff = (current_time >= latency_time) ? (current_time - latency_time) : 0;
              latency_atomic.store(diff);
          }

Member Data Documentation

m_clock_ticks_conversion

double dunedaq::trigger::Latency::m_clock_ticks_conversion

private

Definition at line 91 of file Latency.hpp.

m_get_current_time

std::function<uint64_t()> dunedaq::trigger::Latency::m_get_current_time

private

Definition at line 94 of file Latency.hpp.

m_latency_in

std::atomic<latency> dunedaq::trigger::Latency::m_latency_in

private

Definition at line 88 of file Latency.hpp.

m_latency_out

std::atomic<latency> dunedaq::trigger::Latency::m_latency_out

private

Definition at line 89 of file Latency.hpp.

m_time_unit

TimeUnit dunedaq::trigger::Latency::m_time_unit

private

Definition at line 90 of file Latency.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/trigger/include/trigger/Latency.hpp