dunedaq::trigger::TokenManager Class Reference

TokenManager keeps track of the number of in-flight trigger decisions. More...

#include <TokenManager.hpp>

Public Member Functions
	TokenManager (const std::string &connection_name, int initial_tokens, daqdataformats::run_number_t run_number, std::shared_ptr< LivetimeCounter > livetime_counter)
virtual	~TokenManager ()
	TokenManager (TokenManager const &)=delete
	TokenManager (TokenManager &&)=default
TokenManager &	operator= (TokenManager const &)=delete
TokenManager &	operator= (TokenManager &&)=default
int	get_n_tokens () const
bool	triggers_allowed () const
void	trigger_sent (dfmessages::trigger_number_t)

Private Member Functions
void	receive_token (dfmessages::TriggerDecisionToken &token)

Private Attributes
std::string	m_connection_name
std::atomic< bool >	m_running_flag
std::atomic< int >	m_n_tokens
std::set< dfmessages::trigger_number_t >	m_open_trigger_decisions
std::mutex	m_open_trigger_decisions_mutex
daqdataformats::run_number_t	m_run_number
std::shared_ptr< LivetimeCounter >	m_livetime_counter
std::chrono::time_point< std::chrono::steady_clock >	m_open_trigger_time
std::shared_ptr< iomanager::ReceiverConcept< dfmessages::TriggerDecisionToken > >	m_token_receiver

Detailed Description

TokenManager keeps track of the number of in-flight trigger decisions.

TokenManager implements a credit-based system for trigger inhibits. It is constructed with an initial number of tokens and a queue of dfmessages::TriggerDecisionToken. When a trigger decision is sent, the number of tokens is decremented, and when a TriggerDecisionToken is received on the queue, the number of tokens is incremented. When the count of available tokens reaches zero, no further TriggerDecisions may be issued.

Definition at line 39 of file TokenManager.hpp.

Constructor & Destructor Documentation

TokenManager() [1/3]

dunedaq::trigger::TokenManager::TokenManager	(	const std::string &	connection_name,
		int	initial_tokens,
		daqdataformats::run_number_t	run_number,
		std::shared_ptr< LivetimeCounter >	livetime_counter )

Definition at line 19 of file TokenManager.cpp.

  : m_connection_name(connection_name)
  , m_n_tokens(initial_tokens)
  , m_run_number(run_number)
  , m_livetime_counter(livetime_counter)
  , m_token_receiver(nullptr)
{
  m_open_trigger_time = std::chrono::steady_clock::now();
 
  m_token_receiver = get_iom_receiver<dfmessages::TriggerDecisionToken>(m_connection_name);
  m_token_receiver->add_callback(std::bind(&TokenManager::receive_token, this, std::placeholders::_1));
}

~TokenManager()

dunedaq::trigger::TokenManager::~TokenManager ( )

virtual

Definition at line 35 of file TokenManager.cpp.

{
  m_token_receiver->remove_callback();
 
  if (!m_open_trigger_decisions.empty()) {
 
    auto now = std::chrono::steady_clock::now();
    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - m_open_trigger_time) >
        std::chrono::milliseconds(3000)) {
      std::ostringstream o;
      o << "Open Trigger Decisions: [";
      { // Scope for lock_guard
        bool first = true;
        std::lock_guard<std::mutex> lk(m_open_trigger_decisions_mutex);
        for (auto& td : m_open_trigger_decisions) {
          if (!first)
            o << ", ";
          o << td;
          first = false;
        }
        o << "]";
      }
      TLOG_DEBUG(0) << o.str();
    }
  }
}

TokenManager() [2/3]

dunedaq::trigger::TokenManager::TokenManager ( TokenManager const & )

delete

TokenManager() [3/3]

dunedaq::trigger::TokenManager::TokenManager ( TokenManager && )

default

Member Function Documentation

get_n_tokens()

int dunedaq::trigger::TokenManager::get_n_tokens

(

)

const

Get the number of available tokens

Definition at line 63 of file TokenManager.cpp.

{
  return m_n_tokens.load();
}

operator=() [1/2]

TokenManager & dunedaq::trigger::TokenManager::operator= ( TokenManager && )

default

operator=() [2/2]

TokenManager & dunedaq::trigger::TokenManager::operator= ( TokenManager const & )

delete

receive_token()

void dunedaq::trigger::TokenManager::receive_token ( dfmessages::TriggerDecisionToken & token )

private

Definition at line 80 of file TokenManager.cpp.

{
  TLOG_DEBUG(1) << "Received token with run number " << token.run_number << ", current run number " << m_run_number;
  if (token.run_number == m_run_number) {
    if (m_n_tokens.load() == 0) {
      m_livetime_counter->set_state(LivetimeCounter::State::kLive);
    }
    m_n_tokens++;
    TLOG_DEBUG(1) << "There are now " << m_n_tokens.load() << " tokens available";
 
    if (token.trigger_number != dfmessages::TypeDefaults::s_invalid_trigger_number) {
      if (m_open_trigger_decisions.count(token.trigger_number)) {
        std::lock_guard<std::mutex> lk(m_open_trigger_decisions_mutex);
        m_open_trigger_decisions.erase(token.trigger_number);
        TLOG_DEBUG(1) << "Token indicates that trigger decision " << token.trigger_number
                      << " has been completed. There are now " << m_open_trigger_decisions.size()
                      << " triggers in flight";
      } else {
        // ERS warning: received token for trigger number I don't recognize
      }
    }
  }
}

trigger_sent()

void dunedaq::trigger::TokenManager::trigger_sent

(

dfmessages::trigger_number_t

trigger_number

)

Notify TokenManager that a trigger decision has been sent. This decreases the number of available tokens by one.

Note: you should call this function before pushing the corresponding TriggerDecision to its output queue. If you do these steps in the other order, the TriggerComplete message may be returned before TokenManager is aware of the corresponding trigger decision

Definition at line 69 of file TokenManager.cpp.

{
  std::lock_guard<std::mutex> lk(m_open_trigger_decisions_mutex);
  m_open_trigger_decisions.insert(trigger_number);
  m_n_tokens--;
  if (m_n_tokens.load() == 0) {
    m_livetime_counter->set_state(LivetimeCounter::State::kDead);
  }
}

triggers_allowed()

bool dunedaq::trigger::TokenManager::triggers_allowed ( ) const

inline

Are tokens currently available, to allow sending of new trigger decisions?

Definition at line 62 of file TokenManager.hpp.

{ return get_n_tokens() > 0; }

Member Data Documentation

m_connection_name

std::string dunedaq::trigger::TokenManager::m_connection_name

private

Definition at line 78 of file TokenManager.hpp.

m_livetime_counter

std::shared_ptr<LivetimeCounter> dunedaq::trigger::TokenManager::m_livetime_counter

private

Definition at line 90 of file TokenManager.hpp.

m_n_tokens

std::atomic<int> dunedaq::trigger::TokenManager::m_n_tokens

private

Definition at line 83 of file TokenManager.hpp.

m_open_trigger_decisions

std::set<dfmessages::trigger_number_t> dunedaq::trigger::TokenManager::m_open_trigger_decisions

private

Definition at line 86 of file TokenManager.hpp.

m_open_trigger_decisions_mutex

std::mutex dunedaq::trigger::TokenManager::m_open_trigger_decisions_mutex

private

Definition at line 87 of file TokenManager.hpp.

m_open_trigger_time

std::chrono::time_point<std::chrono::steady_clock> dunedaq::trigger::TokenManager::m_open_trigger_time

private

Definition at line 93 of file TokenManager.hpp.

m_run_number

daqdataformats::run_number_t dunedaq::trigger::TokenManager::m_run_number

private

Definition at line 89 of file TokenManager.hpp.

m_running_flag

std::atomic<bool> dunedaq::trigger::TokenManager::m_running_flag

private

Definition at line 81 of file TokenManager.hpp.

m_token_receiver

std::shared_ptr<iomanager::ReceiverConcept<dfmessages::TriggerDecisionToken> > dunedaq::trigger::TokenManager::m_token_receiver

private

Definition at line 96 of file TokenManager.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/trigger/src/trigger/TokenManager.hpp
• /github/workspace/dunedaq/sourcecode/trigger/src/TokenManager.cpp