dunedaq::dfmodules::TriggerInhibitAgent Class Reference

#include <TriggerInhibitAgent.hpp>

Inheritance diagram for dunedaq::dfmodules::TriggerInhibitAgent:

Collaboration diagram for dunedaq::dfmodules::TriggerInhibitAgent:

Public Types
using	trigdecreceiver_t = iomanager::ReceiverConcept<dfmessages::TriggerDecision>
using	triginhsender_t = iomanager::SenderConcept<dfmessages::TriggerInhibit>

Public Member Functions
	TriggerInhibitAgent (const std::string &, std::shared_ptr< trigdecreceiver_t >, std::shared_ptr< triginhsender_t >)
	TriggerInhibitAgent Constructor.
	TriggerInhibitAgent (const TriggerInhibitAgent &)=delete
	TriggerInhibitAgent is not copy-constructible.
TriggerInhibitAgent &	operator= (const TriggerInhibitAgent &)=delete
	TriggerInhibitAgent is not copy-assignable.
	TriggerInhibitAgent (TriggerInhibitAgent &&)=delete
	TriggerInhibitAgent is not move-constructible.
TriggerInhibitAgent &	operator= (TriggerInhibitAgent &&)=delete
	TriggerInhibitAgent is not move-assignable.
void	start_checking ()
void	stop_checking ()
void	set_threshold_for_inhibit (uint32_t value)
void	set_latest_trigger_number (daqdataformats::trigger_number_t trig_num)
Public Member Functions inherited from dunedaq::utilities::NamedObject
	NamedObject (const std::string &name)
	NamedObject Constructor.
	NamedObject (NamedObject const &)=delete
	NamedObject is not copy-constructible.
	NamedObject (NamedObject &&)=default
	NamedObject is move-constructible.
NamedObject &	operator= (NamedObject const &)=delete
	NamedObject is not copy-assignable.
NamedObject &	operator= (NamedObject &&)=default
	NamedObject is move-assignable.
virtual	~NamedObject ()=default
	Default virtual destructor.
const std::string &	get_name () const final
	Get the name of this NamedObejct.
Public Member Functions inherited from dunedaq::utilities::Named
	Named ()=default
	Named Constructor.
	Named (Named const &)=delete
	Named is not copy-constructible.
	Named (Named &&)=default
	Named is move-constructible.
Named &	operator= (Named const &)=delete
	Named is not copy-assignable.
Named &	operator= (Named &&)=default
	Named is move-assignable.
virtual	~Named ()=default
	Default virtual destructor.

Private Member Functions
void	do_work (std::atomic< bool > &)

Private Attributes
dunedaq::utilities::WorkerThread	m_thread
std::chrono::milliseconds	m_queue_timeout
std::atomic< uint32_t >	m_threshold_for_inhibit
std::shared_ptr< trigdecreceiver_t >	m_trigger_decision_receiver
std::shared_ptr< triginhsender_t >	m_trigger_inhibit_sender
std::atomic< daqdataformats::trigger_number_t >	m_trigger_number_at_start_of_processing_chain
std::atomic< daqdataformats::trigger_number_t >	m_trigger_number_at_end_of_processing_chain

Detailed Description

Definition at line 36 of file TriggerInhibitAgent.hpp.

Member Typedef Documentation

trigdecreceiver_t

using dunedaq::dfmodules::TriggerInhibitAgent::trigdecreceiver_t = iomanager::ReceiverConcept<dfmessages::TriggerDecision>

Definition at line 39 of file TriggerInhibitAgent.hpp.

triginhsender_t

using dunedaq::dfmodules::TriggerInhibitAgent::triginhsender_t = iomanager::SenderConcept<dfmessages::TriggerInhibit>

Definition at line 40 of file TriggerInhibitAgent.hpp.

Constructor & Destructor Documentation

TriggerInhibitAgent() [1/3]

dunedaq::dfmodules::TriggerInhibitAgent::TriggerInhibitAgent ( const std::string & parent_name, std::shared_ptr< trigdecreceiver_t > our_input, std::shared_ptr< triginhsender_t > our_output )

explicit

TriggerInhibitAgent Constructor.

Definition at line 31 of file TriggerInhibitAgent.cpp.

  : NamedObject(parent_name + "::TriggerInhibitAgent")
  , m_thread(std::bind(&TriggerInhibitAgent::do_work, this, std::placeholders::_1))
  , m_queue_timeout(100)
  , m_threshold_for_inhibit(1)
  , m_trigger_decision_receiver(our_input)
  , m_trigger_inhibit_sender(our_output)
  , m_trigger_number_at_start_of_processing_chain(0)
  , m_trigger_number_at_end_of_processing_chain(0)
{
}

TriggerInhibitAgent() [2/3]

dunedaq::dfmodules::TriggerInhibitAgent::TriggerInhibitAgent ( const TriggerInhibitAgent & )

delete

TriggerInhibitAgent is not copy-constructible.

TriggerInhibitAgent() [3/3]

dunedaq::dfmodules::TriggerInhibitAgent::TriggerInhibitAgent ( TriggerInhibitAgent && )

delete

TriggerInhibitAgent is not move-constructible.

Member Function Documentation

do_work()

void dunedaq::dfmodules::TriggerInhibitAgent::do_work ( std::atomic< bool > & running_flag )

private

Definition at line 64 of file TriggerInhibitAgent.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Entering do_work() method";
 
  // configuration (hard-coded, for now; will be input from calling code later)
  int fake_busy_interval_sec = 0;
  std::chrono::seconds chrono_fake_busy_interval(fake_busy_interval_sec);
  int fake_busy_duration_sec = 0;
  std::chrono::seconds chrono_fake_busy_duration(fake_busy_duration_sec);
  int min_interval_between_inhibit_messages_msec = 0;
  std::chrono::milliseconds chrono_min_interval_between_inhibit_messages(min_interval_between_inhibit_messages_msec);
 
  // initialization
  enum LocalState
  {
    no_update,
    free_state,
    busy_state
  };
  std::chrono::steady_clock::time_point current_time = std::chrono::steady_clock::now();
  // std::chrono::steady_clock::time_point start_time_of_latest_fake_busy = current_time - chrono_fake_busy_duration;
  std::chrono::steady_clock::time_point last_sent_time = current_time;
  LocalState requested_state = no_update;
  LocalState current_state = free_state;
  int32_t received_message_count = 0;
  int32_t sent_message_count = 0;
 
  // work loop
  while (running_flag.load()) {
 
    // check if a TriggerDecision message has arrived, and save the trigger
    // number contained within it, if one has arrived
    try {
      dfmessages::TriggerDecision trig_dec = m_trigger_decision_receiver->receive(m_queue_timeout);
      ++received_message_count;
      TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Popped the TriggerDecision for trigger number "
                                  << trig_dec.trigger_number << " off the input queue";
      m_trigger_number_at_start_of_processing_chain.store(trig_dec.trigger_number);
    } catch (const iomanager::TimeoutExpired& excpt) {
      // it is perfectly reasonable that there will be no data in the queue some
      // fraction of the times that we check, so we just continue on and try again later
    }
 
    // to-do: add some logic to fake inhibits
 
    // check if A) we are supposed to be checking the trigger_number difference, and
    // B) if so, whether an Inhibit should be asserted or cleared
    uint32_t threshold = m_threshold_for_inhibit.load(); // NOLINT
    if (threshold > 0) {
      daqdataformats::trigger_number_t temp_trig_num_at_start = m_trigger_number_at_start_of_processing_chain.load();
      daqdataformats::trigger_number_t temp_trig_num_at_end = m_trigger_number_at_end_of_processing_chain.load();
      if (temp_trig_num_at_start >= temp_trig_num_at_end &&
          (temp_trig_num_at_start - temp_trig_num_at_end) >= threshold) {
        if (current_state == free_state) {
          requested_state = busy_state;
        }
      } else {
        if (current_state == busy_state) {
          requested_state = free_state;
        }
      }
    }
 
    // to-do: add some logic to periodically send a message even if nothing has changed
 
    // send an Inhibit messages, if needed (either Busy or Free state)
    if (requested_state != no_update && requested_state != current_state) {
      if ((std::chrono::steady_clock::now() - last_sent_time) >= chrono_min_interval_between_inhibit_messages) {
        dfmessages::TriggerInhibit inhibit_message;
        if (requested_state == busy_state) {
          inhibit_message.busy = true;
        } else {
          inhibit_message.busy = false;
        }
 
        TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Pushing a TriggerInhibit message with busy state set to "
                                    << inhibit_message.busy << " onto the output queue";
        try {
          m_trigger_inhibit_sender->send(std::move(inhibit_message), m_queue_timeout);
          ++sent_message_count;
#if 0
          // temporary logging
          std::ostringstream oss_sent;
          oss_sent << ": Successfully pushed a TriggerInhibit message with busy state set to " << inhibit_message.busy
                   << " onto the output queue";
          TLOG() << ProgressUpdate(ERS_HERE, get_name(), oss_sent.str());
#endif
          // if we successfully pushed the message to the Sink, then we assume that the
          // receiver will get it, and we update our internal state accordingly
          current_state = requested_state;
          requested_state = no_update;
          last_sent_time = std::chrono::steady_clock::now();
        } catch (const iomanager::TimeoutExpired& excpt) {
          // It is not ideal if we fail to send the inhibit message out, but rather than
          // retrying some unknown number of times, we simply output a TRACE message and
          // go on.  This has the benefit of being responsive with pulling TriggerDecision
          // messages off the input queue, and maybe our Busy/Free state will have changed
          // by the time that the receiver is ready to receive more messages.
          TLOG_DEBUG(TLVL_WORK_STEPS) << get_name()
                                      << ": TIMEOUT pushing a TriggerInhibit message onto the output queue";
        }
      }
    }
  }
 
  std::ostringstream oss_summ;
  oss_summ << ": Exiting the do_work() method, received " << received_message_count
           << " TriggerDecision messages and sent " << sent_message_count
           << " TriggerInhibit messages of all types (both Busy and Free).";
  TLOG() << ProgressUpdate(ERS_HERE, get_name(), oss_summ.str());
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting do_work() method";
}

operator=() [1/2]

TriggerInhibitAgent & dunedaq::dfmodules::TriggerInhibitAgent::operator= ( const TriggerInhibitAgent & )

delete

TriggerInhibitAgent is not copy-assignable.

operator=() [2/2]

TriggerInhibitAgent & dunedaq::dfmodules::TriggerInhibitAgent::operator= ( TriggerInhibitAgent && )

delete

TriggerInhibitAgent is not move-assignable.

set_latest_trigger_number()

void dunedaq::dfmodules::TriggerInhibitAgent::set_latest_trigger_number ( daqdataformats::trigger_number_t trig_num )

inline

Definition at line 63 of file TriggerInhibitAgent.hpp.

  {
    m_trigger_number_at_end_of_processing_chain.store(trig_num);
  }

set_threshold_for_inhibit()

void dunedaq::dfmodules::TriggerInhibitAgent::set_threshold_for_inhibit ( uint32_t value )

inline

Definition at line 58 of file TriggerInhibitAgent.hpp.

  {
    m_threshold_for_inhibit.store(value);
  }

start_checking()

void dunedaq::dfmodules::TriggerInhibitAgent::start_checking

(

)

Definition at line 46 of file TriggerInhibitAgent.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Entering start_checking() method";
  m_thread.start_working_thread();
  TLOG() << get_name() << " successfully started";
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting start_checking() method";
}

stop_checking()

void dunedaq::dfmodules::TriggerInhibitAgent::stop_checking

(

)

Definition at line 55 of file TriggerInhibitAgent.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Entering stop_checking() method";
  m_thread.stop_working_thread();
  TLOG() << get_name() << " successfully stopped";
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting stop_checking() method";
}

Member Data Documentation

m_queue_timeout

std::chrono::milliseconds dunedaq::dfmodules::TriggerInhibitAgent::m_queue_timeout

private

Definition at line 74 of file TriggerInhibitAgent.hpp.

m_thread

dunedaq::utilities::WorkerThread dunedaq::dfmodules::TriggerInhibitAgent::m_thread

private

Definition at line 70 of file TriggerInhibitAgent.hpp.

m_threshold_for_inhibit

std::atomic<uint32_t> dunedaq::dfmodules::TriggerInhibitAgent::m_threshold_for_inhibit

private

Definition at line 75 of file TriggerInhibitAgent.hpp.

m_trigger_decision_receiver

std::shared_ptr<trigdecreceiver_t> dunedaq::dfmodules::TriggerInhibitAgent::m_trigger_decision_receiver

private

Definition at line 78 of file TriggerInhibitAgent.hpp.

m_trigger_inhibit_sender

std::shared_ptr<triginhsender_t> dunedaq::dfmodules::TriggerInhibitAgent::m_trigger_inhibit_sender

private

Definition at line 79 of file TriggerInhibitAgent.hpp.

m_trigger_number_at_end_of_processing_chain

std::atomic<daqdataformats::trigger_number_t> dunedaq::dfmodules::TriggerInhibitAgent::m_trigger_number_at_end_of_processing_chain

private

Definition at line 83 of file TriggerInhibitAgent.hpp.

m_trigger_number_at_start_of_processing_chain

std::atomic<daqdataformats::trigger_number_t> dunedaq::dfmodules::TriggerInhibitAgent::m_trigger_number_at_start_of_processing_chain

private

Definition at line 82 of file TriggerInhibitAgent.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/dfmodules/src/dfmodules/TriggerInhibitAgent.hpp
• /github/workspace/dunedaq/sourcecode/dfmodules/src/TriggerInhibitAgent.cpp