dunedaq::timinglibs::TimingHardwareManagerBase Class Reference

TimingHardwareManagerBase creates vectors of ints and writes them to the configured output queues. More...

#include <TimingHardwareManagerBase.hpp>

Inheritance diagram for dunedaq::timinglibs::TimingHardwareManagerBase:

Collaboration diagram for dunedaq::timinglibs::TimingHardwareManagerBase:

Public Member Functions
	TimingHardwareManagerBase (const std::string &name)
	TimingHardwareManagerBase Constructor.
	TimingHardwareManagerBase (const TimingHardwareManagerBase &)=delete
	TimingHardwareManagerBase is not copy-constructible.
TimingHardwareManagerBase &	operator= (const TimingHardwareManagerBase &)=delete
	TimingHardwareManagerBase is not copy-assignable.
	TimingHardwareManagerBase (TimingHardwareManagerBase &&)=delete
	TimingHardwareManagerBase is not move-constructible.
TimingHardwareManagerBase &	operator= (TimingHardwareManagerBase &&)=delete
	TimingHardwareManagerBase is not move-assignable.
virtual	~TimingHardwareManagerBase ()
void	init (std::shared_ptr< appfwk::ConfigurationManager > mcfg) override
virtual void	conf (const CommandData_t &data)
Public Member Functions inherited from dunedaq::timinglibs::TimingHardwareInterface
	TimingHardwareInterface ()
	TimingHardwareInterface Constructor.
	TimingHardwareInterface (const TimingHardwareInterface &)=delete
	TimingHardwareInterface is not copy-constructible.
TimingHardwareInterface &	operator= (const TimingHardwareInterface &)=delete
	TimingHardwareInterface is not copy-assignable.
	TimingHardwareInterface (TimingHardwareInterface &&)=delete
	TimingHardwareInterface is not move-constructible.
TimingHardwareInterface &	operator= (TimingHardwareInterface &&)=delete
	TimingHardwareInterface is not move-assignable.

Protected Types
using	source_t = dunedaq::iomanager::ReceiverConcept<timingcmd::TimingHwCmd>

Protected Member Functions
virtual void	do_scrap (const CommandData_t &)
virtual void	process_hardware_command (timingcmd::TimingHwCmd &timing_hw_cmd)
virtual void	register_common_hw_commands_for_design ()=0
virtual void	register_master_hw_commands_for_design ()=0
virtual void	register_endpoint_hw_commands_for_design ()=0
virtual void	register_hsi_hw_commands_for_design ()=0
template<class TIMING_DEV>
TIMING_DEV	get_timing_device (const std::string &device_name)
const timing::TimingNode *	get_timing_device_plain (const std::string &device_name)
template<typename Child>
void	register_timing_hw_command (const std::string &hw_cmd_id, void(Child::*f)(const timingcmd::TimingHwCmd &))
void	io_reset (const timingcmd::TimingHwCmd &hw_cmd)
void	print_status (const timingcmd::TimingHwCmd &hw_cmd)
void	set_timestamp (const timingcmd::TimingHwCmd &hw_cmd)
void	set_endpoint_delay (const timingcmd::TimingHwCmd &hw_cmd)
void	send_fl_cmd (const timingcmd::TimingHwCmd &hw_cmd)
void	master_endpoint_scan (const timingcmd::TimingHwCmd &hw_cmd)
virtual void	partition_configure (const timingcmd::TimingHwCmd &hw_cmd)=0
void	endpoint_enable (const timingcmd::TimingHwCmd &hw_cmd)
void	endpoint_disable (const timingcmd::TimingHwCmd &hw_cmd)
void	endpoint_reset (const timingcmd::TimingHwCmd &hw_cmd)
void	hsi_reset (const timingcmd::TimingHwCmd &hw_cmd)
void	hsi_configure (const timingcmd::TimingHwCmd &hw_cmd)
void	hsi_start (const timingcmd::TimingHwCmd &hw_cmd)
void	hsi_stop (const timingcmd::TimingHwCmd &hw_cmd)
void	hsi_print_status (const timingcmd::TimingHwCmd &hw_cmd)
void	register_info_gatherer (uint gather_interval, const std::string &device_name, int op_mon_level)
void	gather_monitor_data (InfoGatherer &gatherer)
virtual void	start_hw_mon_gathering (const std::string &device_name="")
virtual void	stop_hw_mon_gathering (const std::string &device_name="")
virtual std::vector< std::string >	check_hw_mon_gatherer_is_running (const std::string &device_name)
virtual void	perform_endpoint_scan (const timingcmd::TimingHwCmd &hw_cmd)
virtual void	clean_endpoint_scan_threads ()
Protected Member Functions inherited from dunedaq::timinglibs::TimingHardwareInterface
template<class TIMING_DEV>
TIMING_DEV	cast_timing_device (const uhal::Node *device_node, std::string timing_device_name)
void	configure_uhal (const dunedaq::timinglibs::dal::TimingHardwareInterfaceConf *mdal)
void	configure_uhal (const std::string &uhal_log_level, const std::string &connections_file)
void	scrap_uhal ()

Protected Attributes
std::string	m_hw_cmd_connection
std::shared_ptr< source_t >	m_hw_command_receiver
uint	m_gather_interval
uint	m_gather_interval_debug
std::map< std::string, std::unique_ptr< uhal::HwInterface > >	m_hw_device_map
std::mutex	m_hw_device_map_mutex
std::string	m_monitored_device_name_master
std::map< uint, std::string >	m_monitored_device_names_fanout
std::string	m_monitored_device_name_endpoint
std::string	m_monitored_device_name_hsi
std::map< timingcmd::TimingHwCmdId, std::function< void(const timingcmd::TimingHwCmd &)> >	m_timing_hw_cmd_map_
std::atomic< uint64_t >	m_received_hw_commands_counter
std::atomic< uint64_t >	m_accepted_hw_commands_counter
std::atomic< uint64_t >	m_rejected_hw_commands_counter
std::atomic< uint64_t >	m_failed_hw_commands_counter
std::map< std::string, std::unique_ptr< InfoGatherer > >	m_info_gatherers
std::mutex	m_command_threads_map_mutex
std::map< std::string, std::unique_ptr< std::thread > >	m_command_threads
std::mutex	master_sfp_mutex
std::unique_ptr< dunedaq::utilities::ReusableThread >	m_endpoint_scan_threads_clean_up_thread
std::atomic< bool >	m_run_endpoint_scan_cleanup_thread
const timinglibs::dal::TimingHardwareManagerConf *	m_params
std::map< uint, int >	m_monitored_endpoints_round_trip_times
Protected Attributes inherited from dunedaq::timinglibs::TimingHardwareInterface
std::string	m_connections_file
std::string	m_uhal_log_level
std::unique_ptr< uhal::ConnectionManager >	m_connection_manager

Detailed Description

TimingHardwareManagerBase creates vectors of ints and writes them to the configured output queues.

Definition at line 52 of file TimingHardwareManagerBase.hpp.

Member Typedef Documentation

source_t

using dunedaq::timinglibs::TimingHardwareManagerBase::source_t = dunedaq::iomanager::ReceiverConcept<timingcmd::TimingHwCmd>

protected

Definition at line 87 of file TimingHardwareManagerBase.hpp.

Constructor & Destructor Documentation

TimingHardwareManagerBase() [1/3]

dunedaq::timinglibs::TimingHardwareManagerBase::TimingHardwareManagerBase ( const std::string & name )

explicit

TimingHardwareManagerBase Constructor.

Parameters

name	Instance name for this TimingHardwareManagerBase instance

Definition at line 39 of file TimingHardwareManagerBase.cpp.

  : dunedaq::appfwk::DAQModule(name)
  , m_hw_cmd_connection("timing_cmds")
  , m_hw_command_receiver(nullptr)
  , m_gather_interval(1e6)
  , m_gather_interval_debug(10e6)
  , m_monitored_device_name_master("")
  , m_monitored_device_name_endpoint("")
  , m_monitored_device_name_hsi("")
  , m_received_hw_commands_counter{ 0 }
  , m_accepted_hw_commands_counter{ 0 }
  , m_rejected_hw_commands_counter{ 0 }
  , m_failed_hw_commands_counter{ 0 }
  , m_endpoint_scan_threads_clean_up_thread(nullptr)
{
  //  register_command("start", &TimingHardwareManagerBase::do_start);
  //  register_command("stop", &TimingHardwareManagerBase::do_stop);
  register_command("scrap", &TimingHardwareManagerBase::do_scrap);
}

TimingHardwareManagerBase() [2/3]

dunedaq::timinglibs::TimingHardwareManagerBase::TimingHardwareManagerBase ( const TimingHardwareManagerBase & )

delete

TimingHardwareManagerBase is not copy-constructible.

TimingHardwareManagerBase() [3/3]

dunedaq::timinglibs::TimingHardwareManagerBase::TimingHardwareManagerBase ( TimingHardwareManagerBase && )

delete

TimingHardwareManagerBase is not move-constructible.

~TimingHardwareManagerBase()

virtual dunedaq::timinglibs::TimingHardwareManagerBase::~TimingHardwareManagerBase ( )

inlinevirtual

Definition at line 71 of file TimingHardwareManagerBase.hpp.

{}

Member Function Documentation

check_hw_mon_gatherer_is_running()

std::vector< std::string > dunedaq::timinglibs::TimingHardwareManagerBase::check_hw_mon_gatherer_is_running ( const std::string & device_name )

protectedvirtual

Definition at line 271 of file TimingHardwareManagerBase.cpp.

{
  std::vector<std::string> running_gatherers;
  for (auto it = m_info_gatherers.lower_bound(device_name); it != m_info_gatherers.end(); ++it) {
    TLOG_DEBUG(0) << get_name() << " Checking run state of info gatherer: " << it->first << ", and the state is "
                  << it->second.get()->run_gathering();
    if (it->second.get()->run_gathering()) {
      running_gatherers.push_back(it->first);
    }
  }
  return running_gatherers;
}

clean_endpoint_scan_threads()

void dunedaq::timinglibs::TimingHardwareManagerBase::clean_endpoint_scan_threads ( )

protectedvirtual

Definition at line 482 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << "Entering clean_endpoint_scan_threads()";
  bool break_flag = false;
  while (!break_flag) {
    for (auto& thread : m_command_threads) {
      if (thread.second->joinable()) {
        std::unique_lock map_lock(m_command_threads_map_mutex);
        TLOG_DEBUG(2) << thread.first << " thread ready. Cleaning up.";
        thread.second->join();
        m_command_threads.erase(thread.first);
      }
    }
 
    auto prev_clean_time = std::chrono::steady_clock::now();
    auto next_clean_time = prev_clean_time + std::chrono::milliseconds(30);
 
    // check running_flag periodically
    auto flag_check_period = std::chrono::milliseconds(1);
    auto next_flag_check_time = prev_clean_time + flag_check_period;
 
    while (next_clean_time > next_flag_check_time + flag_check_period) {
      if (!m_run_endpoint_scan_cleanup_thread.load()) {
        TLOG_DEBUG(2) << "while waiting to clean up endpoint scan threads, negative run gatherer flag detected.";
        break_flag = true;
        break;
      }
      std::this_thread::sleep_until(next_flag_check_time);
      next_flag_check_time = next_flag_check_time + flag_check_period;
    }
    if (break_flag == false) {
      std::this_thread::sleep_until(next_clean_time);
    }
  }
  TLOG_DEBUG(0) << "Exiting clean_endpoint_scan_threads()";
}

conf()

void dunedaq::timinglibs::TimingHardwareManagerBase::conf ( const CommandData_t & data )

virtual

Definition at line 83 of file TimingHardwareManagerBase.cpp.

{
  m_received_hw_commands_counter = 0;
  m_accepted_hw_commands_counter = 0;
  m_rejected_hw_commands_counter = 0;
  m_failed_hw_commands_counter = 0;
 
  m_gather_interval = m_params->get_gather_interval();
  m_gather_interval_debug = m_params->get_gather_interval_debug();
 
  m_monitored_device_name_master = m_params->get_monitored_device_name_master();
  for (auto fanout : m_params->get_monitored_device_names_fanout()) {
    TLOG_DEBUG(3) << fanout->get_device() << ": device, slot: " << fanout->get_fanout_slot() << std::endl;
    m_monitored_device_names_fanout.emplace(fanout->get_fanout_slot(), fanout->get_device());
  }
 
  m_monitored_device_name_endpoint = m_params->get_monitored_device_name_endpoint();
  m_monitored_device_name_hsi = m_params->get_monitored_device_name_hsi();
 
  configure_uhal(m_params); // configure hw ipbus connection
 
  m_hw_command_receiver->add_callback(
    std::bind(&TimingHardwareManagerBase::process_hardware_command, this, std::placeholders::_1));
 
  m_run_endpoint_scan_cleanup_thread.store(true);
  m_endpoint_scan_threads_clean_up_thread->set_work(&TimingHardwareManagerBase::clean_endpoint_scan_threads, this);
}

do_scrap()

void dunedaq::timinglibs::TimingHardwareManagerBase::do_scrap ( const CommandData_t & )

protectedvirtual

Definition at line 112 of file TimingHardwareManagerBase.cpp.

{
  m_hw_command_receiver->remove_callback();
 
  auto time_of_scrap = std::chrono::high_resolution_clock::now();
  while (m_command_threads.size()) {
    auto now = std::chrono::high_resolution_clock::now();
    auto ms_since_scrap = std::chrono::duration_cast<std::chrono::milliseconds>(now - time_of_scrap);
    TLOG_DEBUG(0) << "Have been waiting for " << ms_since_scrap.count() << " ms for " << m_command_threads.size()
                  << " command threads to finish...";
    std::this_thread::sleep_for(std::chrono::microseconds(250000));
  }
  m_run_endpoint_scan_cleanup_thread.store(false);
 
  stop_hw_mon_gathering();
 
  scrap_uhal();
 
  m_command_threads.clear();
  m_info_gatherers.clear();
  m_timing_hw_cmd_map_.clear();
  m_hw_device_map.clear();
  m_connection_manager.reset();
}

endpoint_disable()

void dunedaq::timinglibs::TimingHardwareManagerBase::endpoint_disable ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 568 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::TimingEndpointCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " ept disable";
 
  auto design = get_timing_device<const timing::EndpointDesignInterface*>(hw_cmd.device);
  design->get_endpoint_node_plain(cmd_payload.endpoint_id)->disable();
}

endpoint_enable()

void dunedaq::timinglibs::TimingHardwareManagerBase::endpoint_enable ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 555 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::TimingEndpointConfigureCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " ept enable, adr: " << cmd_payload.address
                << ", part: " << cmd_payload.partition;
 
  auto design = get_timing_device<const timing::EndpointDesignInterface*>(hw_cmd.device);
  design->get_endpoint_node_plain(cmd_payload.endpoint_id)->enable(cmd_payload.address, cmd_payload.partition);
}

endpoint_reset()

void dunedaq::timinglibs::TimingHardwareManagerBase::endpoint_reset ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 580 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::TimingEndpointConfigureCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " ept reset, adr: " << cmd_payload.address
                << ", part: " << cmd_payload.partition;
 
  auto design = get_timing_device<const timing::EndpointDesignInterface*>(hw_cmd.device);
  design->get_endpoint_node_plain(cmd_payload.endpoint_id)->reset(cmd_payload.address, cmd_payload.partition);
}

gather_monitor_data()

void dunedaq::timinglibs::TimingHardwareManagerBase::gather_monitor_data ( InfoGatherer & gatherer )

protected

Definition at line 170 of file TimingHardwareManagerBase.cpp.

{
  auto device_name = gatherer.get_device_name();
 
  while (gatherer.run_gathering()) {
 
    // collect the data from the hardware
    try {
      auto design = get_timing_device<const timing::TopDesignInterface*>(device_name);
 
      gatherer.collect_info_from_device(*design);
    } catch (const std::exception& excpt) {
      ers::warning(FailedToCollectOpMonInfo(ERS_HERE, device_name, excpt));
    }
 
    auto prev_gather_time = std::chrono::steady_clock::now();
    auto next_gather_time = prev_gather_time + std::chrono::microseconds(gatherer.get_gather_interval());
 
    // check running_flag periodically
    auto slice_period = std::chrono::microseconds(10000);
    auto next_slice_gather_time = prev_gather_time + slice_period;
 
    bool break_flag = false;
    while (next_gather_time > next_slice_gather_time + slice_period) {
      if (!gatherer.run_gathering()) {
        TLOG_DEBUG(0) << "while waiting to gather data, negative run gatherer flag detected.";
        break_flag = true;
        break;
      }
      std::this_thread::sleep_until(next_slice_gather_time);
      next_slice_gather_time = next_slice_gather_time + slice_period;
    }
    if (break_flag == false) {
      std::this_thread::sleep_until(next_gather_time);
    }
  }
}

get_timing_device()

template<class TIMING_DEV>

TIMING_DEV dunedaq::timinglibs::TimingHardwareManagerBase::get_timing_device ( const std::string & device_name )

protected

Definition at line 22 of file TimingHardwareManagerBase.hxx.

{
  auto device = get_timing_device_plain(device_name);
  auto timing_device = cast_timing_device<TIMING_DEV>(device, device_name);
  return timing_device;
}

get_timing_device_plain()

const timing::TimingNode * dunedaq::timinglibs::TimingHardwareManagerBase::get_timing_device_plain ( const std::string & device_name )

protected

Definition at line 138 of file TimingHardwareManagerBase.cpp.

{
 
  if (!device_name.compare("")) {
    std::stringstream message;
    message << "UHAL device name is an empty string";
    throw UHALDeviceNameIssue(ERS_HERE, message.str());
  }
 
  if (auto hw_device_entry = m_hw_device_map.find(device_name); hw_device_entry != m_hw_device_map.end()) {
    return dynamic_cast<const timing::TimingNode*>(&hw_device_entry->second->getNode(""));
  } else {
    TLOG_DEBUG(0) << get_name() << ": hw device interface for: " << device_name
                  << " does not exist. I will try to create it.";
 
    try {
      std::lock_guard<std::mutex> hw_device_map_guard(m_hw_device_map_mutex);
      m_hw_device_map.emplace(device_name,
                              std::make_unique<uhal::HwInterface>(m_connection_manager->getDevice(device_name)));
    } catch (const uhal::exception::ConnectionUIDDoesNotExist& exception) {
      std::stringstream message;
      message << "UHAL device name not " << device_name << " in connections file";
      throw UHALDeviceNameIssue(ERS_HERE, message.str(), exception);
    }
 
    TLOG_DEBUG(0) << get_name() << ": hw device interface for: " << device_name << " successfully created.";
 
    return dynamic_cast<const timing::TimingNode*>(&m_hw_device_map.find(device_name)->second->getNode(""));
  }
}

hsi_configure()

void dunedaq::timinglibs::TimingHardwareManagerBase::hsi_configure ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 603 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::HSIConfigureCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " hsi configure";
 
  auto design = get_timing_device<const timing::HSIDesignInterface*>(hw_cmd.device);
  design->configure_hsi(cmd_payload.data_source,
                        cmd_payload.rising_edge_mask,
                        cmd_payload.falling_edge_mask,
                        cmd_payload.invert_edge_mask,
                        cmd_payload.random_rate);
}

hsi_print_status()

void dunedaq::timinglibs::TimingHardwareManagerBase::hsi_print_status ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 637 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " hsi print status";
 
  auto design = get_timing_device<const timing::HSIDesignInterface*>(hw_cmd.device);
  TLOG() << std::endl << design->get_hsi_node().get_status();
}

hsi_reset()

void dunedaq::timinglibs::TimingHardwareManagerBase::hsi_reset ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 594 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " hsi reset";
 
  auto design = get_timing_device<const timing::HSIDesignInterface*>(hw_cmd.device);
  design->get_hsi_node().reset_hsi();
}

hsi_start()

void dunedaq::timinglibs::TimingHardwareManagerBase::hsi_start ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 619 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " hsi start";
 
  auto design = get_timing_device<const timing::HSIDesignInterface*>(hw_cmd.device);
  design->get_hsi_node().start_hsi();
}

hsi_stop()

void dunedaq::timinglibs::TimingHardwareManagerBase::hsi_stop ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 628 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " hsi stop";
 
  auto design = get_timing_device<const timing::HSIDesignInterface*>(hw_cmd.device);
  design->get_hsi_node().stop_hsi();
}

init()

void dunedaq::timinglibs::TimingHardwareManagerBase::init ( std::shared_ptr< appfwk::ConfigurationManager > mcfg )

override

Definition at line 60 of file TimingHardwareManagerBase.cpp.

{
  auto mod_config = mcfg->get_dal<timinglibs::dal::TimingHardwareManagerBase>(get_name());
  m_params = mod_config->get_configuration();
 
  // set up queues
  for (auto con : mod_config->get_inputs()) {
    if (con->get_data_type() == datatype_to_string<timingcmd::TimingHwCmd>()) {
      m_hw_cmd_connection = con->UID();
      TLOG() << "m_hw_cmd_connection: " << m_hw_cmd_connection;
    }
  }
 
  try {
    m_hw_command_receiver = iomanager::IOManager::get()->get_receiver<timingcmd::TimingHwCmd>(m_hw_cmd_connection);
  } catch (const ers::Issue& excpt) {
    throw InvalidQueueFatalError(ERS_HERE, get_name(), "input", excpt);
  }
 
  m_endpoint_scan_threads_clean_up_thread = std::make_unique<dunedaq::utilities::ReusableThread>(0);
}

io_reset()

void dunedaq::timinglibs::TimingHardwareManagerBase::io_reset ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 324 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::IOResetCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " io reset";
 
  // io reset disrupts hw mon gathering, so stop if running
  auto running_hw_gatherers = check_hw_mon_gatherer_is_running(hw_cmd.device);
  for (auto& gatherer : running_hw_gatherers) {
    stop_hw_mon_gathering(gatherer);
  }
 
  auto design = get_timing_device<const timing::TopDesignInterface*>(hw_cmd.device);
 
  if (cmd_payload.soft) {
    TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " soft io reset";
    design->soft_reset_io();
  } else if (!cmd_payload.clock_config.empty()) {
    TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device
                  << " io reset, with supplied clk file: " << cmd_payload.clock_config;
    design->reset_io(cmd_payload.clock_config);
  } else {
    TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device
                  << " io reset, with supplied clk source: " << cmd_payload.clock_source;
    design->reset_io(static_cast<timing::ClockSource>(cmd_payload.clock_source));
  }
 
  // if hw mon gathering was running previously, start it again
  for (auto& gatherer : running_hw_gatherers) {
    start_hw_mon_gathering(gatherer);
  }
}

master_endpoint_scan()

void dunedaq::timinglibs::TimingHardwareManagerBase::master_endpoint_scan ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 382 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " master_endpoint_scan";
 
  std::stringstream command_thread_uid;
  auto t = std::time(nullptr);
  auto tm = *std::localtime(&t);
  command_thread_uid << "enpoint_scan_cmd_at_" << std::put_time(&tm, "%d-%m-%Y %H-%M-%S") << "_cmd_num_"
                     << m_accepted_hw_commands_counter.load();
 
  if (m_command_threads.size() > 5) {
    ers::warning(TooManyEndpointScanThreadsQueued(ERS_HERE, m_command_threads.size()));
  } else {
    TLOG_DEBUG(1) << "Queuing: " << command_thread_uid.str();
 
    auto thread_key = command_thread_uid.str();
    std::unique_lock map_lock(m_command_threads_map_mutex);
 
    m_command_threads.emplace(
      thread_key,
      std::make_unique<std::thread>(std::bind(&TimingHardwareManagerBase::perform_endpoint_scan, this, hw_cmd)));
  }
}

operator=() [1/2]

TimingHardwareManagerBase & dunedaq::timinglibs::TimingHardwareManagerBase::operator= ( const TimingHardwareManagerBase & )

delete

TimingHardwareManagerBase is not copy-assignable.

operator=() [2/2]

TimingHardwareManagerBase & dunedaq::timinglibs::TimingHardwareManagerBase::operator= ( TimingHardwareManagerBase && )

delete

TimingHardwareManagerBase is not move-assignable.

partition_configure()

virtual void dunedaq::timinglibs::TimingHardwareManagerBase::partition_configure ( const timingcmd::TimingHwCmd & hw_cmd )

protectedpure virtual

perform_endpoint_scan()

void dunedaq::timinglibs::TimingHardwareManagerBase::perform_endpoint_scan ( const timingcmd::TimingHwCmd & hw_cmd )

protectedvirtual

Definition at line 407 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::TimingMasterEndpointScanPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  for (auto& endpoint_location : cmd_payload.endpoints) {
    auto endpoint_address = endpoint_location.address;
    auto fanout_slot = endpoint_location.fanout_slot;
    auto sfp_slot = endpoint_location.sfp_slot;
 
    std::unique_lock<std::mutex> master_sfp_lock(master_sfp_mutex);
 
    TLOG_DEBUG(1) << get_name() << ": " << hw_cmd.device
                  << " master_endpoint_scan starting: ept adr: " << endpoint_address << ", ept sfp: " << sfp_slot
                  << ", fanout slot: " << fanout_slot;
 
    auto master_design = get_timing_device<const timing::MasterDesignInterface*>(hw_cmd.device);
    try {
      // master_design->get_master_node_plain()->switch_endpoint_sfp(endpoint_address, true);
 
      if (sfp_slot >= 0) {
        if (fanout_slot >= 0) {
          // configure fanout/FIB
          try {
            get_timing_device<const timing::MuxDesignInterface*>(m_monitored_device_names_fanout.at(fanout_slot))
              ->switch_mux(sfp_slot);
          } catch (const UHALDeviceClassIssue& e) {
            ers::error(e);
            continue;
          }
 
          // slot 0 for board without multiple data tx paths, e.g. FMC, TLU
          if (fanout_slot != 0) {
            // configure GIB/MIB
            try {
              get_timing_device<const timing::MuxDesignInterface*>(hw_cmd.device)->switch_mux(fanout_slot - 1);
            } catch (const UHALDeviceClassIssue& e) {
              ers::error(e);
              continue;
            }
          }
        } else {
          dynamic_cast<const timing::MuxDesignInterface*>(master_design)->switch_mux(sfp_slot);
        }
      }
 
      auto scan_result = master_design->get_master_node_plain()->scan_endpoint(endpoint_address, true);
      if (scan_result.alive) {
        auto current_rtt = scan_result.round_trip_time;
        ers::info(EndpointRTTMeasurement(ERS_HERE, fanout_slot, sfp_slot, endpoint_address, current_rtt));
        if (m_monitored_endpoints_round_trip_times.count(endpoint_address)) {
          auto previous_rtt = m_monitored_endpoints_round_trip_times[endpoint_address];
          if (previous_rtt != current_rtt) {
            // TLOG() << "New round trip time for endpoint " << endpoint_address << " measured. Previous: "
            //   << m_monitored_endpoints_round_trip_times[endpoint_address] << ", current: " << current_rtt;
            ers::warning(ChangedEndpointRTTMeasurement(
              ERS_HERE, fanout_slot, sfp_slot, endpoint_address, current_rtt, previous_rtt));
          }
        } else {
          // TLOG() << "First measured round trip time for endpoint " << endpoint_address << " is: " << current_rtt;
        }
        m_monitored_endpoints_round_trip_times[endpoint_address] = current_rtt;
      } else {
        ers::error(EndpointUnresponsive(ERS_HERE, fanout_slot, sfp_slot, endpoint_address));
        // TLOG() << endpoint_address << " endpoint was not alive...";
      }
      // master_design->get_master_node_plain()->switch_endpoint_sfp(endpoint_address, false);
    } catch (std::exception& e) {
      ers::error(EndpointScanFailure(ERS_HERE, e));
      master_design->get_master_node_plain()->switch_endpoint_sfp(endpoint_address, false);
    }
  }
}

print_status()

void dunedaq::timinglibs::TimingHardwareManagerBase::print_status ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 359 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " print status";
 
  auto design = get_timing_device<const timing::TopDesignInterface*>(hw_cmd.device);
  TLOG() << std::endl << design->get_status();
}

process_hardware_command()

void dunedaq::timinglibs::TimingHardwareManagerBase::process_hardware_command ( timingcmd::TimingHwCmd & timing_hw_cmd )

protectedvirtual

Definition at line 287 of file TimingHardwareManagerBase.cpp.

{
  std::ostringstream starting_stream;
  starting_stream << ": Executing process_hardware_command() callback.";
  TLOG_DEBUG(0) << get_name() << starting_stream.str();
 
  ++m_received_hw_commands_counter;
 
  TLOG_DEBUG(0) << get_name() << ": Received hardware command #" << m_received_hw_commands_counter.load()
                << ", it is of type: " << timing_hw_cmd.id << ", targeting device: " << timing_hw_cmd.device
                << ", with payload: " << timing_hw_cmd.payload.dump();
 
  std::string hw_cmd_name = timing_hw_cmd.id;
  if (auto cmd = m_timing_hw_cmd_map_.find(hw_cmd_name); cmd != m_timing_hw_cmd_map_.end()) {
 
    ++m_accepted_hw_commands_counter;
 
    TLOG_DEBUG(0) << "Found hw cmd: " << hw_cmd_name;
    try {
      std::invoke(cmd->second, timing_hw_cmd);
    } catch (const std::exception& exception) {
      ers::error(FailedToExecuteHardwareCommand(ERS_HERE, hw_cmd_name, timing_hw_cmd.device, exception));
      ++m_failed_hw_commands_counter;
    }
  } else {
    ers::error(InvalidHardwareCommandID(ERS_HERE, hw_cmd_name));
    ++m_rejected_hw_commands_counter;
  }
 
  std::ostringstream exiting_stream;
  exiting_stream << ": Finished executing process_hardware_command() callback. Received "
                 << m_received_hw_commands_counter.load() << " commands";
  TLOG_DEBUG(0) << get_name() << exiting_stream.str();
}

register_common_hw_commands_for_design()

virtual void dunedaq::timinglibs::TimingHardwareManagerBase::register_common_hw_commands_for_design ( )

protectedpure virtual

register_endpoint_hw_commands_for_design()

virtual void dunedaq::timinglibs::TimingHardwareManagerBase::register_endpoint_hw_commands_for_design ( )

protectedpure virtual

register_hsi_hw_commands_for_design()

virtual void dunedaq::timinglibs::TimingHardwareManagerBase::register_hsi_hw_commands_for_design ( )

protectedpure virtual

register_info_gatherer()

void dunedaq::timinglibs::TimingHardwareManagerBase::register_info_gatherer ( uint gather_interval, const std::string & device_name, int op_mon_level )

protected

Definition at line 209 of file TimingHardwareManagerBase.cpp.

{
  std::string gatherer_name = device_name + "_level_" + std::to_string(op_mon_level);
  if (m_info_gatherers.find(gatherer_name) == m_info_gatherers.end()) {
    std::unique_ptr<InfoGatherer> gatherer = std::make_unique<InfoGatherer>(
      std::bind(&TimingHardwareManagerBase::gather_monitor_data, this, std::placeholders::_1),
      gather_interval,
      device_name,
      op_mon_level);
 
    TLOG_DEBUG(0) << "Registering info gatherer: " << gatherer_name;
    m_info_gatherers.emplace(std::make_pair(gatherer_name, std::move(gatherer)));
  } else {
    TLOG() << "Skipping registration of " << gatherer_name << ". Already exists.";
  }
}

register_master_hw_commands_for_design()

virtual void dunedaq::timinglibs::TimingHardwareManagerBase::register_master_hw_commands_for_design ( )

protectedpure virtual

register_timing_hw_command()

template<class Child>

void dunedaq::timinglibs::TimingHardwareManagerBase::register_timing_hw_command ( const std::string & hw_cmd_id, void(Child::* f )(const timingcmd::TimingHwCmd &) )

protected

Definition at line 5 of file TimingHardwareManagerBase.hxx.

{
  using namespace std::placeholders;
 
  std::string hw_cmd_name = hw_cmd_id;
  TLOG_DEBUG(0) << "Registering timing hw command id: " << hw_cmd_name << " called with " << typeid(f).name()
                << std::endl;
 
  bool done = m_timing_hw_cmd_map_.emplace(hw_cmd_name, std::bind(f, dynamic_cast<Child*>(this), _1)).second;
  if (!done) {
    throw TimingHardwareCommandRegistrationFailed(ERS_HERE, hw_cmd_name, get_name());
  }
}

send_fl_cmd()

void dunedaq::timinglibs::TimingHardwareManagerBase::send_fl_cmd ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 539 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::TimingMasterSendFLCmdCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " send fl cmd. Payload: " << hw_cmd.payload.dump()
                << ", parsed data: " << cmd_payload.fl_cmd_id << ", " << cmd_payload.channel << ", "
                << cmd_payload.number_of_commands_to_send;
 
  auto design = get_timing_device<const timing::MasterDesignInterface*>(hw_cmd.device);
  design->get_master_node_plain()->send_fl_cmd(
    cmd_payload.fl_cmd_id, cmd_payload.channel, cmd_payload.number_of_commands_to_send);
}

set_endpoint_delay()

void dunedaq::timinglibs::TimingHardwareManagerBase::set_endpoint_delay ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 521 of file TimingHardwareManagerBase.cpp.

{
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device << " set endpoint delay";
 
  timingcmd::TimingMasterSetEndpointDelayCmdPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  auto design = get_timing_device<const timing::MasterDesignInterface*>(hw_cmd.device);
  design->apply_endpoint_delay(cmd_payload.address,
                               cmd_payload.coarse_delay,
                               cmd_payload.fine_delay,
                               cmd_payload.phase_delay,
                               cmd_payload.measure_rtt,
                               cmd_payload.control_sfp,
                               cmd_payload.sfp_mux);
}

set_timestamp()

void dunedaq::timinglibs::TimingHardwareManagerBase::set_timestamp ( const timingcmd::TimingHwCmd & hw_cmd )

protected

Definition at line 369 of file TimingHardwareManagerBase.cpp.

{
  timingcmd::SyncTimestampPayload cmd_payload;
  timingcmd::from_json(hw_cmd.payload, cmd_payload);
 
  TLOG_DEBUG(0) << get_name() << ": " << hw_cmd.device
                << " set timestamp, with supplied ts source: " << cmd_payload.timestamp_source;
 
  auto design = get_timing_device<const timing::MasterDesignInterface*>(hw_cmd.device);
  design->sync_timestamp(static_cast<timing::TimestampSource>(cmd_payload.timestamp_source));
}

start_hw_mon_gathering()

void dunedaq::timinglibs::TimingHardwareManagerBase::start_hw_mon_gathering ( const std::string & device_name = "" )

protectedvirtual

Definition at line 229 of file TimingHardwareManagerBase.cpp.

{
  // start all gatherers if no device name is given
  if (!device_name.compare("")) {
    TLOG_DEBUG(0) << get_name() << " Starting all info gatherers";
    for (auto it = m_info_gatherers.begin(); it != m_info_gatherers.end(); ++it)
      it->second.get()->start_gathering_thread();
  } else {
    // find gatherer for suppled device name and start it
    bool gatherer_found = false;
    for (auto it = m_info_gatherers.lower_bound(device_name); it != m_info_gatherers.end(); ++it) {
      TLOG_DEBUG(0) << get_name() << " Starting info gatherer: " << it->first;
      it->second.get()->start_gathering_thread();
      gatherer_found = true;
    }
    if (!gatherer_found)
      ers::warning(AttemptedToControlNonExantInfoGatherer(ERS_HERE, "start", device_name));
  }
}

stop_hw_mon_gathering()

void dunedaq::timinglibs::TimingHardwareManagerBase::stop_hw_mon_gathering ( const std::string & device_name = "" )

protectedvirtual

Definition at line 250 of file TimingHardwareManagerBase.cpp.

{
  // stop all gatherers if no device name is given
  if (!device_name.compare("")) {
    TLOG_DEBUG(0) << get_name() << " Stopping all info gatherers";
    for (auto it = m_info_gatherers.begin(); it != m_info_gatherers.end(); ++it)
      it->second.get()->stop_gathering_thread();
  } else {
    // find gatherer for suppled device name and stop it
    bool gatherer_found = false;
    for (auto it = m_info_gatherers.lower_bound(device_name); it != m_info_gatherers.end(); ++it) {
      TLOG_DEBUG(0) << get_name() << " Stopping info gatherer: " << it->first;
      it->second.get()->stop_gathering_thread();
      gatherer_found = true;
    }
    if (!gatherer_found)
      ers::warning(AttemptedToControlNonExantInfoGatherer(ERS_HERE, "stop", device_name));
  }
}

Member Data Documentation

m_accepted_hw_commands_counter

std::atomic<uint64_t> dunedaq::timinglibs::TimingHardwareManagerBase::m_accepted_hw_commands_counter

protected

Definition at line 148 of file TimingHardwareManagerBase.hpp.

m_command_threads

std::map<std::string, std::unique_ptr<std::thread> > dunedaq::timinglibs::TimingHardwareManagerBase::m_command_threads

protected

Definition at line 163 of file TimingHardwareManagerBase.hpp.

m_command_threads_map_mutex

std::mutex dunedaq::timinglibs::TimingHardwareManagerBase::m_command_threads_map_mutex

protected

Definition at line 162 of file TimingHardwareManagerBase.hpp.

m_endpoint_scan_threads_clean_up_thread

std::unique_ptr<dunedaq::utilities::ReusableThread> dunedaq::timinglibs::TimingHardwareManagerBase::m_endpoint_scan_threads_clean_up_thread

protected

Definition at line 167 of file TimingHardwareManagerBase.hpp.

m_failed_hw_commands_counter

std::atomic<uint64_t> dunedaq::timinglibs::TimingHardwareManagerBase::m_failed_hw_commands_counter

protected

Definition at line 150 of file TimingHardwareManagerBase.hpp.

m_gather_interval

uint dunedaq::timinglibs::TimingHardwareManagerBase::m_gather_interval

protected

Definition at line 92 of file TimingHardwareManagerBase.hpp.

m_gather_interval_debug

uint dunedaq::timinglibs::TimingHardwareManagerBase::m_gather_interval_debug

protected

Definition at line 93 of file TimingHardwareManagerBase.hpp.

m_hw_cmd_connection

std::string dunedaq::timinglibs::TimingHardwareManagerBase::m_hw_cmd_connection

protected

Definition at line 86 of file TimingHardwareManagerBase.hpp.

m_hw_command_receiver

std::shared_ptr<source_t> dunedaq::timinglibs::TimingHardwareManagerBase::m_hw_command_receiver

protected

Definition at line 88 of file TimingHardwareManagerBase.hpp.

m_hw_device_map

std::map<std::string, std::unique_ptr<uhal::HwInterface> > dunedaq::timinglibs::TimingHardwareManagerBase::m_hw_device_map

protected

Definition at line 96 of file TimingHardwareManagerBase.hpp.

m_hw_device_map_mutex

std::mutex dunedaq::timinglibs::TimingHardwareManagerBase::m_hw_device_map_mutex

protected

Definition at line 97 of file TimingHardwareManagerBase.hpp.

m_info_gatherers

std::map<std::string, std::unique_ptr<InfoGatherer> > dunedaq::timinglibs::TimingHardwareManagerBase::m_info_gatherers

protected

Definition at line 153 of file TimingHardwareManagerBase.hpp.

m_monitored_device_name_endpoint

std::string dunedaq::timinglibs::TimingHardwareManagerBase::m_monitored_device_name_endpoint

protected

Definition at line 102 of file TimingHardwareManagerBase.hpp.

m_monitored_device_name_hsi

std::string dunedaq::timinglibs::TimingHardwareManagerBase::m_monitored_device_name_hsi

protected

Definition at line 103 of file TimingHardwareManagerBase.hpp.

m_monitored_device_name_master

std::string dunedaq::timinglibs::TimingHardwareManagerBase::m_monitored_device_name_master

protected

Definition at line 100 of file TimingHardwareManagerBase.hpp.

m_monitored_device_names_fanout

std::map<uint, std::string> dunedaq::timinglibs::TimingHardwareManagerBase::m_monitored_device_names_fanout

protected

Definition at line 101 of file TimingHardwareManagerBase.hpp.

m_monitored_endpoints_round_trip_times

std::map<uint, int> dunedaq::timinglibs::TimingHardwareManagerBase::m_monitored_endpoints_round_trip_times

protected

Definition at line 170 of file TimingHardwareManagerBase.hpp.

m_params

const timinglibs::dal::TimingHardwareManagerConf* dunedaq::timinglibs::TimingHardwareManagerBase::m_params

protected

Definition at line 169 of file TimingHardwareManagerBase.hpp.

m_received_hw_commands_counter

std::atomic<uint64_t> dunedaq::timinglibs::TimingHardwareManagerBase::m_received_hw_commands_counter

protected

Definition at line 147 of file TimingHardwareManagerBase.hpp.

m_rejected_hw_commands_counter

std::atomic<uint64_t> dunedaq::timinglibs::TimingHardwareManagerBase::m_rejected_hw_commands_counter

protected

Definition at line 149 of file TimingHardwareManagerBase.hpp.

m_run_endpoint_scan_cleanup_thread

std::atomic<bool> dunedaq::timinglibs::TimingHardwareManagerBase::m_run_endpoint_scan_cleanup_thread

protected

Definition at line 168 of file TimingHardwareManagerBase.hpp.

m_timing_hw_cmd_map_

std::map<timingcmd::TimingHwCmdId, std::function<void(const timingcmd::TimingHwCmd&)> > dunedaq::timinglibs::TimingHardwareManagerBase::m_timing_hw_cmd_map_

protected

Definition at line 116 of file TimingHardwareManagerBase.hpp.

master_sfp_mutex

std::mutex dunedaq::timinglibs::TimingHardwareManagerBase::master_sfp_mutex

protected

Definition at line 164 of file TimingHardwareManagerBase.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/timinglibs/src/TimingHardwareManagerBase.hpp
• /github/workspace/dunedaq/sourcecode/timinglibs/src/detail/TimingHardwareManagerBase.hxx
• /github/workspace/dunedaq/sourcecode/timinglibs/src/TimingHardwareManagerBase.cpp