dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType > Class Template Reference

#include <SNBRequestHandlerModel.hpp>

Inheritance diagram for dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >:

Collaboration diagram for dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >:

Classes
struct	RequestElement

Public Types
using	RDT = ReadoutType
using	LBT = LatencyBufferType
using	RequestResult
using	ResultCode
Public Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string

Public Member Functions
	SNBRequestHandlerModel (std::shared_ptr< LatencyBufferType > &latency_buffer, std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &error_registry)
void	conf (const dunedaq::appmodel::DataHandlerModule *)
void	scrap (const appfwk::DAQModule::CommandData_t &) override
void	start (const appfwk::DAQModule::CommandData_t &)
void	stop (const appfwk::DAQModule::CommandData_t &)
void	record (const appfwk::DAQModule::CommandData_t &args) override
void	cleanup_check () override
	Check if cleanup is necessary and execute it if necessary.
virtual void	periodic_data_transmission () override
	Periodic data transmission - relevant for trigger in particular.
void	issue_request (dfmessages::DataRequest datarequest, bool is_retry=false) override
	Issue a data request to the request handler.
virtual dunedaq::daqdataformats::timestamp_t	get_cutoff_timestamp ()
virtual bool	supports_cutoff_timestamp ()
void	reset_oldest_time ()
std::uint64_t	get_oldest_time () override
	Get oldest timestamp in the buffer.
Public Member Functions inherited from dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >
	RequestHandlerConcept ()
virtual	~RequestHandlerConcept ()
	RequestHandlerConcept (const RequestHandlerConcept &)=delete
	RequestHandlerConcept is not copy-constructible.
RequestHandlerConcept &	operator= (const RequestHandlerConcept &)=delete
	RequestHandlerConcept is not copy-assginable.
	RequestHandlerConcept (RequestHandlerConcept &&)=delete
	RequestHandlerConcept is not move-constructible.
RequestHandlerConcept &	operator= (RequestHandlerConcept &&)=delete
	RequestHandlerConcept is not move-assignable.
Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject (const MonitorableObject &)=delete
MonitorableObject &	operator= (const MonitorableObject &)=delete
	MonitorableObject (MonitorableObject &&)=delete
MonitorableObject &	operator= (MonitorableObject &&)=delete
virtual	~MonitorableObject ()=default
auto	get_opmon_id () const noexcept
auto	get_opmon_level () const noexcept

Protected Member Functions
daqdataformats::FragmentHeader	create_fragment_header (const dfmessages::DataRequest &dr)
std::unique_ptr< daqdataformats::Fragment >	create_empty_fragment (const dfmessages::DataRequest &dr)
void	dump_to_buffer (const void *data, std::size_t size, void *buffer, uint32_t buffer_pos, const std::size_t &buffer_size)
void	periodic_cleanups ()
void	periodic_data_transmissions ()
void	cleanup ()
void	check_waiting_requests ()
std::vector< std::pair< void *, size_t > >	get_fragment_pieces (uint64_t start_win_ts, uint64_t end_win_ts, RequestResult &rres)
RequestResult	data_request (dfmessages::DataRequest dr) override
virtual void	generate_opmon_data () override
Protected Member Functions inherited from dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >
const std::string &	resultCodeAsString (ResultCode rc)
Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject ()=default
void	register_node (ElementId name, NewNodePtr)
void	publish (google::protobuf::Message &&, CustomOrigin &&co={}, OpMonLevel l=to_level(EntryOpMonLevel::kDefault)) const noexcept

Protected Attributes
std::shared_ptr< LatencyBufferType > &	m_latency_buffer
datahandlinglibs::BufferedFileWriter	m_buffered_writer
utilities::ReusableThread	m_recording_thread
utilities::ReusableThread	m_cleanup_thread
utilities::ReusableThread	m_periodic_transmission_thread
std::map< dfmessages::DataRequest, int >	m_request_counter
std::mutex	m_cv_mutex
std::condition_variable	m_cv
std::atomic< bool >	m_cleanup_requested = false
std::atomic< int >	m_requests_running = 0
std::vector< RequestElement >	m_waiting_requests
std::mutex	m_waiting_requests_lock
std::unique_ptr< boost::asio::thread_pool >	m_request_handler_thread_pool
size_t	m_num_request_handling_threads = 0
std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &	m_error_registry
std::chrono::time_point< std::chrono::high_resolution_clock >	m_t0
std::atomic< bool >	m_run_marker = false
std::thread	m_waiting_queue_thread
std::atomic< bool >	m_recording = false
std::atomic< uint64_t >	m_next_timestamp_to_record = std::numeric_limits<uint64_t>::max()
bool	m_configured
std::mutex	m_pop_list_mutex
std::set< uint64_t >	m_pop_list
size_t	m_buffer_capacity
daqdataformats::SourceID	m_sourceid
uint16_t	m_detid
std::string	m_output_file
size_t	m_stream_buffer_size = 0
bool	m_recording_configured = false
bool	m_warn_on_timeout = true
bool	m_warn_about_empty_buffer = true
uint32_t	m_periodic_data_transmission_ms = 0
std::vector< std::string >	m_frag_out_conn_ids
std::atomic< int >	m_pop_counter
std::atomic< int >	m_num_buffer_cleanups { 0 }
std::atomic< int >	m_pop_reqs
std::atomic< int >	m_pops_count
std::atomic< int >	m_occupancy
std::atomic< int >	m_num_requests_found { 0 }
std::atomic< int >	m_num_requests_bad { 0 }
std::atomic< int >	m_num_requests_old_window { 0 }
std::atomic< int >	m_num_requests_delayed { 0 }
std::atomic< int >	m_num_requests_uncategorized { 0 }
std::atomic< int >	m_num_requests_timed_out { 0 }
std::atomic< int >	m_handled_requests { 0 }
std::atomic< int >	m_response_time_acc { 0 }
std::atomic< int >	m_response_time_min { std::numeric_limits<int>::max() }
std::atomic< int >	m_response_time_max { 0 }
std::atomic< int >	m_payloads_written { 0 }
std::atomic< int >	m_bytes_written { 0 }
std::atomic< uint64_t >	m_num_periodic_sent { 0 }
std::atomic< uint64_t >	m_num_periodic_send_failed { 0 }
std::atomic< uint64_t >	m_oldest_timestamp { 0 }
int	m_fragment_send_timeout_ms
Protected Attributes inherited from dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >
std::map< ResultCode, std::string >	ResultCodeStrings

Private Attributes
int	m_request_timeout_ms

Additional Inherited Members
Static Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept
Protected Types inherited from dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >
enum	ResultCode {   kFound = 0 , kNotFound , kTooOld , kNotYet ,   kPartial , kPartiallyOld , kCleanup , kUnknown }

Detailed Description

template<class ReadoutType, class LatencyBufferType>
class dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >

Definition at line 80 of file SNBRequestHandlerModel.hpp.

Member Typedef Documentation

LBT

template<class ReadoutType , class LatencyBufferType >

using dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::LBT = LatencyBufferType

Definition at line 85 of file SNBRequestHandlerModel.hpp.

RDT

template<class ReadoutType , class LatencyBufferType >

using dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::RDT = ReadoutType

Definition at line 84 of file SNBRequestHandlerModel.hpp.

RequestResult

template<class ReadoutType , class LatencyBufferType >

using dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::RequestResult

Initial value:

 
    typename dunedaq::datahandlinglibs::RequestHandlerConcept<ReadoutType, LatencyBufferType>::RequestResult

Definition at line 87 of file SNBRequestHandlerModel.hpp.

ResultCode

template<class ReadoutType , class LatencyBufferType >

using dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::ResultCode

Initial value:

 
    typename dunedaq::datahandlinglibs::RequestHandlerConcept<ReadoutType, LatencyBufferType>::ResultCode

Definition at line 89 of file SNBRequestHandlerModel.hpp.

Constructor & Destructor Documentation

SNBRequestHandlerModel()

template<class ReadoutType , class LatencyBufferType >

dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::SNBRequestHandlerModel ( std::shared_ptr< LatencyBufferType > & latency_buffer, std::unique_ptr< datahandlinglibs::FrameErrorRegistry > & error_registry )

inlineexplicit

Definition at line 93 of file SNBRequestHandlerModel.hpp.

    : m_latency_buffer(latency_buffer)
    , m_recording_thread(0)
    , m_cleanup_thread(0)
    , m_waiting_requests()
    , m_waiting_requests_lock()
    , m_error_registry(error_registry)
    , m_buffer_capacity(0)
    , m_pop_counter{ 0 }
    , m_pop_reqs(0)
    , m_pops_count(0)
    , m_occupancy(0)
  //, m_response_time_log()
  //, m_response_time_log_lock()
  {
    TLOG_DEBUG(TLVL_WORK_STEPS) << "SNBRequestHandlerModel created...";
  }

Member Function Documentation

check_waiting_requests()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::check_waiting_requests ( )

protected

Definition at line 325 of file SNBRequestHandlerModel.hxx.

{
  // At run stop, we wait until all waiting requests have either:
  //
  // 1. been serviced because an item past the end of the window arrived in the buffer
  // 2. timed out by going past m_request_timeout_ms, and returned a partial fragment
  while (m_run_marker.load()) {
    if (m_waiting_requests.size() > 0) {
 
      std::lock_guard<std::mutex> lock_guard(m_waiting_requests_lock);
 
      auto last_frame = m_latency_buffer->back();                                       // NOLINT
      uint64_t newest_ts = last_frame == nullptr ? std::numeric_limits<uint64_t>::min() // NOLINT(build/unsigned)
                                                 : last_frame->get_timestamp();
 
      for (auto iter = m_waiting_requests.begin(); iter != m_waiting_requests.end();) {
        if ((*iter).request.request_information.window_end <= newest_ts) {
          issue_request((*iter).request, true);
          iter = m_waiting_requests.erase(iter);
        } else if (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() -
                                                                         (*iter).start_time)
                     .count() >= m_request_timeout_ms) {
          issue_request((*iter).request, true);
          if (m_warn_on_timeout) {
            ers::warning(
              dunedaq::datahandlinglibs::VerboseRequestTimedOut(ERS_HERE,
                                                                m_sourceid,
                                                                (*iter).request.trigger_number,
                                                                (*iter).request.sequence_number,
                                                                (*iter).request.run_number,
                                                                (*iter).request.request_information.window_begin,
                                                                (*iter).request.request_information.window_end,
                                                                (*iter).request.data_destination));
          }
          m_num_requests_bad++;
          m_num_requests_timed_out++;
          iter = m_waiting_requests.erase(iter);
        } else {
          ++iter;
        }
      }
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
}

cleanup()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::cleanup ( )

protectedvirtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 297 of file SNBRequestHandlerModel.hxx.

{
  ++m_pop_reqs;
  unsigned popped = 0;
  {
    std::lock_guard<std::mutex> lk(m_pop_list_mutex);
    while (!m_pop_list.empty() && m_latency_buffer->occupancy() > 1) {
      auto ts = m_latency_buffer->front()->get_timestamp();
      if (m_pop_list.count(ts)) {
        m_latency_buffer->pop(1);
        popped++;
        m_pop_list.erase(ts);
      } else {
        break;
      }
    }
  }
  m_occupancy = m_latency_buffer->occupancy();
  m_pops_count += popped;
  m_error_registry->remove_errors_until(m_latency_buffer->front()->get_timestamp());
 
  // Update hte oldest timestamp monitorable
  m_oldest_timestamp = m_latency_buffer->front()->get_timestamp();
  m_num_buffer_cleanups++;
}

cleanup_check()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::cleanup_check ( )

overridevirtual

Check if cleanup is necessary and execute it if necessary.

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 141 of file SNBRequestHandlerModel.hxx.

{
  std::unique_lock<std::mutex> lock(m_cv_mutex);
  if (!m_pop_list.empty() && !m_cleanup_requested.exchange(true)) {
    m_cv.wait(lock, [&] { return m_requests_running == 0; });
    cleanup();
    m_cleanup_requested = false;
    m_cv.notify_all();
  }
}

conf()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::conf ( const dunedaq::appmodel::DataHandlerModule * conf )

virtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 8 of file SNBRequestHandlerModel.hxx.

{
 
  auto reqh_conf = conf->get_module_configuration()->get_request_handler();
  m_sourceid.id = conf->get_source_id();
  m_sourceid.subsystem = RDT::subsystem;
  m_detid = conf->get_detector_id();
 
  m_buffer_capacity = conf->get_module_configuration()->get_latency_buffer()->get_size();
  m_num_request_handling_threads = reqh_conf->get_handler_threads();
  m_request_timeout_ms = reqh_conf->get_request_timeout();
 
  for (auto output : conf->get_outputs()) {
    if (output->get_data_type() == "Fragment") {
      m_fragment_send_timeout_ms = output->get_send_timeout_ms();
      // 19-Dec-2024, KAB: store the names/IDs of the Fragment output connections so that
      // we can confirm that they are ready for sending at 'start' time.
      m_frag_out_conn_ids.push_back(output->UID());
    }
  }
 
  if (m_recording_configured == false) {
    auto dr = reqh_conf->get_data_recorder();
    if (dr != nullptr) {
      m_output_file = dr->get_output_file();
      if (remove(m_output_file.c_str()) == 0) {
        TLOG_DEBUG(TLVL_WORK_STEPS) << "Removed existing output file from previous run: " << m_output_file << std::endl;
      }
      m_stream_buffer_size = dr->get_streaming_buffer_size();
      m_buffered_writer.open(
        m_output_file, m_stream_buffer_size, dr->get_compression_algorithm(), dr->get_use_o_direct());
      m_recording_configured = true;
    }
  }
 
  m_warn_on_timeout = reqh_conf->get_warn_on_timeout();
  m_warn_about_empty_buffer = reqh_conf->get_warn_on_empty_buffer();
  m_periodic_data_transmission_ms = reqh_conf->get_periodic_data_transmission_ms();
 
  m_recording_thread.set_name("recording", m_sourceid.id);
  m_cleanup_thread.set_name("cleanup", m_sourceid.id);
  m_periodic_transmission_thread.set_name("periodic", m_sourceid.id);
 
  std::ostringstream oss;
  oss << "RequestHandler configured. ";
  TLOG_DEBUG(TLVL_WORK_STEPS) << oss.str();
}

create_empty_fragment()

template<class RDT , class LBT >

std::unique_ptr< daqdataformats::Fragment > dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::create_empty_fragment ( const dfmessages::DataRequest & dr )

protected

Definition at line 260 of file SNBRequestHandlerModel.hxx.

{
  auto frag_header = create_fragment_header(dr);
  frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
  auto fragment = std::make_unique<daqdataformats::Fragment>(std::vector<std::pair<void*, size_t>>());
  fragment->set_header_fields(frag_header);
  return fragment;
}

create_fragment_header()

template<class ReadoutType , class LatencyBufferType >

daqdataformats::FragmentHeader dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::create_fragment_header ( const dfmessages::DataRequest & dr )

inlineprotected

Definition at line 164 of file SNBRequestHandlerModel.hpp.

  {
    daqdataformats::FragmentHeader fh;
    fh.size = sizeof(fh);
    fh.trigger_number = dr.trigger_number;
    fh.trigger_timestamp = dr.trigger_timestamp;
    fh.window_begin = dr.request_information.window_begin;
    fh.window_end = dr.request_information.window_end;
    fh.run_number = dr.run_number;
    fh.fragment_type = static_cast<daqdataformats::fragment_type_t>(ReadoutType::fragment_type);
    fh.sequence_number = dr.sequence_number;
    fh.detector_id = m_detid;
    fh.element_id = { m_sourceid.subsystem, m_sourceid.id };
    return fh;
  }

data_request()

template<class RDT , class LBT >

SNBRequestHandlerModel< RDT, LBT >::RequestResult dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::data_request ( dfmessages::DataRequest dr )

overrideprotectedvirtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 443 of file SNBRequestHandlerModel.hxx.

{
  // Prepare response
  RequestResult rres(ResultCode::kUnknown, dr);
 
  // Prepare FragmentHeader and empty Fragment pieces list
  auto frag_header = create_fragment_header(dr);
  std::vector<std::pair<void*, size_t>> frag_pieces;
  std::ostringstream oss;
 
  // bool local_data_not_found_flag = false;
  if (m_latency_buffer->occupancy() == 0) {
    if (m_warn_about_empty_buffer) {
      ers::warning(datahandlinglibs::RequestOnEmptyBuffer(ERS_HERE, m_sourceid, "Data not found"));
    }
    frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
    rres.result_code = ResultCode::kNotFound;
    ++m_num_requests_bad;
  } else {
    frag_pieces = get_fragment_pieces(dr.request_information.window_begin, dr.request_information.window_end, rres);
 
    auto front_element = m_latency_buffer->front();     // NOLINT
    auto last_element = m_latency_buffer->back();       // NOLINT
    uint64_t last_ts = front_element->get_timestamp();  // NOLINT(build/unsigned)
    uint64_t newest_ts = last_element->get_timestamp(); // NOLINT(build/unsigned)
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Data request for trig/seq_num=" << dr.trigger_number << "." << dr.sequence_number
                                << " and SourceID[" << m_sourceid << "] with" << " Trigger TS=" << dr.trigger_timestamp
                                << " Oldest stored TS=" << last_ts << " Newest stored TS=" << newest_ts
                                << " Start of window TS=" << dr.request_information.window_begin
                                << " End of window TS=" << dr.request_information.window_end
                                << " Latency buffer occupancy=" << m_latency_buffer->occupancy()
                                << " frag_pieces result_code=" << rres.result_code
                                << " number of frag_pieces=" << frag_pieces.size();
 
    switch (rres.result_code) {
      case ResultCode::kTooOld:
        // return empty frag
        ++m_num_requests_old_window;
        ++m_num_requests_bad;
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
        break;
      case ResultCode::kPartiallyOld:
        ++m_num_requests_old_window;
        ++m_num_requests_found;
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kIncomplete));
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
        break;
      case ResultCode::kFound:
        ++m_num_requests_found;
        break;
      case ResultCode::kPartial:
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kIncomplete));
        ++m_num_requests_delayed;
        break;
      case ResultCode::kNotYet:
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
        ++m_num_requests_delayed;
        break;
      default:
        // Unknown result of data search
        ++m_num_requests_bad;
        frag_header.error_bits |= (0x1 << static_cast<size_t>(daqdataformats::FragmentErrorBits::kDataNotFound));
    }
  }
  // Create fragment from pieces
  rres.fragment = std::make_unique<daqdataformats::Fragment>(frag_pieces);
 
  // Set header
  rres.fragment->set_header_fields(frag_header);
 
  return rres;
}

dump_to_buffer()

template<class ReadoutType , class LatencyBufferType >

void dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::dump_to_buffer ( const void * data, std::size_t size, void * buffer, uint32_t buffer_pos, const std::size_t & buffer_size )

inlineprotected

Definition at line 184 of file SNBRequestHandlerModel.hpp.

  {
    auto bytes_to_copy = size;
    while (bytes_to_copy > 0) {
      auto n = std::min(bytes_to_copy, buffer_size - buffer_pos);
      std::memcpy(static_cast<char*>(buffer) + buffer_pos, static_cast<const char*>(data), n);
      buffer_pos += n;
      bytes_to_copy -= n;
      if (buffer_pos == buffer_size) {
        buffer_pos = 0;
      }
    }
  }

generate_opmon_data()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::generate_opmon_data ( )

overrideprotectedvirtual

Hook for customisable pubblication. The function can throw, exception will be caught by the monitoring thread

Reimplemented from dunedaq::opmonlib::MonitorableObject.

Definition at line 208 of file SNBRequestHandlerModel.hxx.

{
  datahandlinglibs::opmon::RequestHandlerInfo info;
 
  info.set_num_requests_handled(m_handled_requests.exchange(0));
  info.set_num_requests_found(m_num_requests_found.exchange(0));
  info.set_num_requests_bad(m_num_requests_bad.exchange(0));
  info.set_num_requests_old_window(m_num_requests_old_window.exchange(0));
  info.set_num_requests_delayed(m_num_requests_delayed.exchange(0));
  info.set_num_requests_uncategorized(m_num_requests_uncategorized.exchange(0));
  info.set_num_requests_timed_out(m_num_requests_timed_out.exchange(0));
  info.set_num_requests_waiting(m_waiting_requests.size());
 
  int new_pop_reqs = 0;
  int new_pop_count = 0;
  int new_occupancy = 0;
  info.set_tot_request_response_time(m_response_time_acc.exchange(0));
  info.set_max_request_response_time(m_response_time_max.exchange(0));
  info.set_min_request_response_time(m_response_time_min.exchange(std::numeric_limits<int>::max()));
  auto now = std::chrono::high_resolution_clock::now();
  new_pop_reqs = m_pop_reqs.exchange(0);
  new_pop_count = m_pops_count.exchange(0);
  new_occupancy = m_occupancy;
  double seconds = std::chrono::duration_cast<std::chrono::microseconds>(now - m_t0).count() / 1000000.;
  TLOG_DEBUG(TLVL_HOUSEKEEPING) << "Cleanup request rate: " << new_pop_reqs / seconds / 1. << " [Hz]"
                                << " Dropped: " << new_pop_count << " Occupancy: " << new_occupancy;
 
  if (info.num_requests_handled() > 0) {
 
    info.set_avg_request_response_time(info.tot_request_response_time() / info.num_requests_handled());
    TLOG_DEBUG(TLVL_HOUSEKEEPING) << "Completed requests: " << info.num_requests_handled()
                                  << " | Avarage response time: " << info.avg_request_response_time() << "[us]"
                                  << " | Periodic sends: " << info.num_periodic_sent();
  }
 
  m_t0 = now;
 
  info.set_num_buffer_cleanups(m_num_buffer_cleanups.exchange(0));
  info.set_num_periodic_sent(m_num_periodic_sent.exchange(0));
  info.set_num_periodic_send_failed(m_num_periodic_send_failed.exchange(0));
 
  this->publish(std::move(info));
 
  datahandlinglibs::opmon::RecordingInfo rinfo;
  rinfo.set_recording_status(m_recording ? "Y" : "N");
  rinfo.set_packets_recorded(m_payloads_written.exchange(0));
  rinfo.set_bytes_recorded(m_bytes_written.exchange(0));
  this->publish(std::move(rinfo));
}

get_cutoff_timestamp()

template<class ReadoutType , class LatencyBufferType >

virtual dunedaq::daqdataformats::timestamp_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::get_cutoff_timestamp ( )

inlinevirtual

Definition at line 153 of file SNBRequestHandlerModel.hpp.

{ return 0; }

get_fragment_pieces()

template<class RDT , class LBT >

std::vector< std::pair< void *, size_t > > dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::get_fragment_pieces ( uint64_t start_win_ts, uint64_t end_win_ts, RequestResult & rres )

protected

Definition at line 373 of file SNBRequestHandlerModel.hxx.

{
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Looking for frags between " << start_win_ts << " and " << end_win_ts;
 
  std::vector<std::pair<void*, size_t>> frag_pieces;
  // Data availability is calculated here
  auto front_element = m_latency_buffer->front();     // NOLINT
  auto last_element = m_latency_buffer->back();       // NOLINT
  uint64_t last_ts = front_element->get_timestamp();  // NOLINT(build/unsigned)
  uint64_t newest_ts = last_element->get_timestamp(); // NOLINT(build/unsigned)
 
  if (start_win_ts > newest_ts) {
    // No element is as small as the start window-> request is far in the future
    rres.result_code = ResultCode::kNotYet; // give it another chance
  } else if (end_win_ts <= last_ts) {
    rres.result_code = ResultCode::kTooOld;
  } else {
    RDT request_element = RDT();
    auto start_timestamp = start_win_ts;
    request_element.set_timestamp(start_timestamp);
 
    auto start_iter = m_latency_buffer->begin();
 
    if (!start_iter.good()) {
      // Accessor problem
      rres.result_code = ResultCode::kNotFound;
    } else {
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Lower bound found " << start_iter->get_timestamp()
                                  << ", --> distance from window: "
                                  << int64_t(start_win_ts) - int64_t(start_iter->get_timestamp());
 
        rres.result_code = ResultCode::kFound;
 
      auto elements_handled = 0;
 
      RDT* element = &(*start_iter);
 
      while (start_iter.good() && element->get_timestamp() <= end_win_ts) {
        std::lock_guard<std::mutex> lk(m_pop_list_mutex);
        if (m_pop_list.count(element->get_timestamp()) ) {
          TLOG_DEBUG(50) << "skip processing for current element " << element->get_timestamp()
                         << ", already included in trigger.";
        }
        else if (element->get_timestamp() < start_win_ts) {
          TLOG_DEBUG(50) << "skip processing for current element " << element->get_timestamp()
                         << ", out of readout window.";
        }
 
        else {
          // TLOG_DEBUG(50) << "Add element " << element->get_timestamp();
          //  SNB mode, the whole aggregated object (e.g.: superchunk) can be copied
          frag_pieces.emplace_back(
            std::make_pair<void*, size_t>(static_cast<void*>((*start_iter).begin()), element->get_payload_size()));
 
          m_pop_list.insert(element->get_timestamp());
        }
 
        elements_handled++;
        ++start_iter;
        element = &(*start_iter);
      }
    }
  }
  TLOG_DEBUG(TLVL_WORK_STEPS) << "*** Number of frames retrieved: " << frag_pieces.size();
  return frag_pieces;
}

get_oldest_time()

template<class ReadoutType , class LatencyBufferType >

std::uint64_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::get_oldest_time ( )

inlineoverridevirtual

Get oldest timestamp in the buffer.

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 160 of file SNBRequestHandlerModel.hpp.

{ return m_oldest_timestamp.load(); } // NOLINT(build/unsigned)

issue_request()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::issue_request ( dfmessages::DataRequest , bool = false )

overridevirtual

Issue a data request to the request handler.

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 154 of file SNBRequestHandlerModel.hxx.

{
  boost::asio::post(*m_request_handler_thread_pool, [&, datarequest, is_retry]() { // start a thread from pool
    auto t_req_begin = std::chrono::high_resolution_clock::now();
    {
      std::unique_lock<std::mutex> lock(m_cv_mutex);
      m_cv.wait(lock, [&] { return !m_cleanup_requested; });
      m_requests_running++;
    }
    m_cv.notify_all();
    auto result = data_request(datarequest);
    {
      std::lock_guard<std::mutex> lock(m_cv_mutex);
      m_requests_running--;
    }
    m_cv.notify_all();
    if ((result.result_code == ResultCode::kNotYet || result.result_code == ResultCode::kPartial) &&
        m_request_timeout_ms > 0 && is_retry == false) {
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Re-queue request. "
                                  << " with timestamp=" << result.data_request.trigger_timestamp;
      std::lock_guard<std::mutex> wait_lock_guard(m_waiting_requests_lock);
      m_waiting_requests.push_back(RequestElement(datarequest, std::chrono::high_resolution_clock::now()));
    } else {
      try { // Send to fragment connection
        TLOG_DEBUG(TLVL_WORK_STEPS) << "Sending fragment with trigger/sequence_number "
                                    << result.fragment->get_trigger_number() << "."
                                    << result.fragment->get_sequence_number() << ", run number "
                                    << result.fragment->get_run_number() << ", and DetectorID "
                                    << result.fragment->get_detector_id() << ", and SourceID "
                                    << result.fragment->get_element_id() << ", and size " << result.fragment->get_size()
                                    << ", and result code " << result.result_code;
        // Send fragment
        get_iom_sender<std::unique_ptr<daqdataformats::Fragment>>(datarequest.data_destination)
          ->send(std::move(result.fragment), std::chrono::milliseconds(m_fragment_send_timeout_ms));
 
      } catch (const ers::Issue& excpt) {
        ers::warning(datahandlinglibs::CannotWriteToQueue(ERS_HERE, m_sourceid, datarequest.data_destination, excpt));
      }
    }
 
    auto t_req_end = std::chrono::high_resolution_clock::now();
    auto us_req_took = std::chrono::duration_cast<std::chrono::microseconds>(t_req_end - t_req_begin);
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Responding to data request took: " << us_req_took.count() << "[us]";
    m_response_time_acc.fetch_add(us_req_took.count());
    if (us_req_took.count() > m_response_time_max.load())
      m_response_time_max.store(us_req_took.count());
    if (us_req_took.count() < m_response_time_min.load())
      m_response_time_min.store(us_req_took.count());
    m_handled_requests++;
  });
}

periodic_cleanups()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::periodic_cleanups ( )

protected

Definition at line 271 of file SNBRequestHandlerModel.hxx.

{
  while (m_run_marker.load()) {
    cleanup_check();
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
  }
}

periodic_data_transmission()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::periodic_data_transmission ( )

overridevirtual

Periodic data transmission - relevant for trigger in particular.

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 291 of file SNBRequestHandlerModel.hxx.

{
}

periodic_data_transmissions()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::periodic_data_transmissions ( )

protected

Definition at line 281 of file SNBRequestHandlerModel.hxx.

{
  while (m_run_marker.load()) {
    periodic_data_transmission();
    std::this_thread::sleep_for(std::chrono::milliseconds(m_periodic_data_transmission_ms));
  }
}

record()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::record ( const appfwk::DAQModule::CommandData_t & args )

overridevirtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 133 of file SNBRequestHandlerModel.hxx.

{
  ers::error(datahandlinglibs::CommandError(ERS_HERE, m_sourceid, "DLH is not configured for recording"));
  return;
}

reset_oldest_time()

template<class ReadoutType , class LatencyBufferType >

void dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::reset_oldest_time ( )

inline

Definition at line 157 of file SNBRequestHandlerModel.hpp.

{ m_oldest_timestamp.store(0); }

scrap()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::scrap ( const appfwk::DAQModule::CommandData_t & )

overridevirtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 58 of file SNBRequestHandlerModel.hxx.

{
  if (m_buffered_writer.is_open()) {
    m_buffered_writer.close();
  }
}

start()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::start ( const appfwk::DAQModule::CommandData_t & )

virtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 67 of file SNBRequestHandlerModel.hxx.

{
  // Reset opmon variables
  m_num_requests_found = 0;
  m_num_requests_bad = 0;
  m_num_requests_old_window = 0;
  m_num_requests_delayed = 0;
  m_num_requests_uncategorized = 0;
  m_num_buffer_cleanups = 0;
  m_num_requests_timed_out = 0;
  m_handled_requests = 0;
  m_response_time_acc = 0;
  m_pop_reqs = 0;
  m_pops_count = 0;
  m_payloads_written = 0;
  m_bytes_written = 0;
 
  m_t0 = std::chrono::high_resolution_clock::now();
 
  // 19-Dec-2024, KAB: check that Fragment senders are ready to send. This is done so
  // that the IOManager infrastructure fetches the necessary connection details from
  // the ConnectivityService at 'start' time, instead of the first time that the sender
  // is used to send data.  This avoids delays in the sending of the first fragment in
  // the first data-taking run in a DAQ session. Such delays can lead to undesirable
  // system behavior like trigger inhibits.
  for (auto frag_out_conn : m_frag_out_conn_ids) {
    auto sender = get_iom_sender<std::unique_ptr<daqdataformats::Fragment>>(frag_out_conn);
    if (sender != nullptr) {
      bool is_ready = sender->is_ready_for_sending(std::chrono::milliseconds(100));
      TLOG_DEBUG(0) << "The Fragment sender for " << frag_out_conn << " " << (is_ready ? "is" : "is not")
                    << " ready, my source_id is [" << m_sourceid << "]";
    }
  }
 
  m_request_handler_thread_pool = std::make_unique<boost::asio::thread_pool>(m_num_request_handling_threads);
 
  m_run_marker.store(true);
  m_cleanup_thread.set_work(&SNBRequestHandlerModel<RDT, LBT>::periodic_cleanups, this);
  if (m_periodic_data_transmission_ms > 0) {
    m_periodic_transmission_thread.set_work(&SNBRequestHandlerModel<RDT, LBT>::periodic_data_transmissions, this);
  }
 
  m_waiting_queue_thread = std::thread(&SNBRequestHandlerModel<RDT, LBT>::check_waiting_requests, this);
}

stop()

template<class RDT , class LBT >

void dunedaq::snbmodules::SNBRequestHandlerModel< RDT, LBT >::stop ( const appfwk::DAQModule::CommandData_t & )

virtual

Implements dunedaq::datahandlinglibs::RequestHandlerConcept< ReadoutType, LatencyBufferType >.

Definition at line 114 of file SNBRequestHandlerModel.hxx.

{
  m_run_marker.store(false);
  while (!m_recording_thread.get_readiness()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
  while (!m_cleanup_thread.get_readiness()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
  while (!m_periodic_transmission_thread.get_readiness()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
  TLOG() << "Latency buffer occupancy at stop: " << m_latency_buffer->occupancy();
  m_waiting_queue_thread.join();
  m_request_handler_thread_pool->join();
}

supports_cutoff_timestamp()

template<class ReadoutType , class LatencyBufferType >

virtual bool dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::supports_cutoff_timestamp ( )

inlinevirtual

Definition at line 154 of file SNBRequestHandlerModel.hpp.

{ return false; }

Member Data Documentation

m_buffer_capacity

template<class ReadoutType , class LatencyBufferType >

size_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_buffer_capacity

protected

Definition at line 265 of file SNBRequestHandlerModel.hpp.

m_buffered_writer

template<class ReadoutType , class LatencyBufferType >

datahandlinglibs::BufferedFileWriter dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_buffered_writer

protected

Definition at line 229 of file SNBRequestHandlerModel.hpp.

m_bytes_written

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_bytes_written { 0 }

protected

Definition at line 293 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_cleanup_requested

template<class ReadoutType , class LatencyBufferType >

std::atomic<bool> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_cleanup_requested = false

protected

Definition at line 241 of file SNBRequestHandlerModel.hpp.

m_cleanup_thread

template<class ReadoutType , class LatencyBufferType >

utilities::ReusableThread dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_cleanup_thread

protected

Definition at line 232 of file SNBRequestHandlerModel.hpp.

m_configured

template<class ReadoutType , class LatencyBufferType >

bool dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_configured

protected

Definition at line 262 of file SNBRequestHandlerModel.hpp.

m_cv

template<class ReadoutType , class LatencyBufferType >

std::condition_variable dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_cv

protected

Definition at line 240 of file SNBRequestHandlerModel.hpp.

m_cv_mutex

template<class ReadoutType , class LatencyBufferType >

std::mutex dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_cv_mutex

protected

Definition at line 239 of file SNBRequestHandlerModel.hpp.

m_detid

template<class ReadoutType , class LatencyBufferType >

uint16_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_detid

protected

Definition at line 267 of file SNBRequestHandlerModel.hpp.

m_error_registry

template<class ReadoutType , class LatencyBufferType >

std::unique_ptr<datahandlinglibs::FrameErrorRegistry>& dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_error_registry

protected

Definition at line 251 of file SNBRequestHandlerModel.hpp.

m_frag_out_conn_ids

template<class ReadoutType , class LatencyBufferType >

std::vector<std::string> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_frag_out_conn_ids

protected

Definition at line 274 of file SNBRequestHandlerModel.hpp.

m_fragment_send_timeout_ms

template<class ReadoutType , class LatencyBufferType >

int dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_fragment_send_timeout_ms

protected

Definition at line 304 of file SNBRequestHandlerModel.hpp.

m_handled_requests

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_handled_requests { 0 }

protected

Definition at line 288 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_latency_buffer

template<class ReadoutType , class LatencyBufferType >

std::shared_ptr<LatencyBufferType>& dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_latency_buffer

protected

Definition at line 226 of file SNBRequestHandlerModel.hpp.

m_next_timestamp_to_record

template<class ReadoutType , class LatencyBufferType >

std::atomic<uint64_t> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_next_timestamp_to_record = std::numeric_limits<uint64_t>::max()

protected

Definition at line 259 of file SNBRequestHandlerModel.hpp.

m_num_buffer_cleanups

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_buffer_cleanups { 0 }

protected

Definition at line 278 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_periodic_send_failed

template<class ReadoutType , class LatencyBufferType >

std::atomic<uint64_t> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_periodic_send_failed { 0 }

protected

Definition at line 295 of file SNBRequestHandlerModel.hpp.

{ 0 }; // NOLINT(build/unsigned)

m_num_periodic_sent

template<class ReadoutType , class LatencyBufferType >

std::atomic<uint64_t> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_periodic_sent { 0 }

protected

Definition at line 294 of file SNBRequestHandlerModel.hpp.

{ 0 };        // NOLINT(build/unsigned)

m_num_request_handling_threads

template<class ReadoutType , class LatencyBufferType >

size_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_request_handling_threads = 0

protected

Definition at line 248 of file SNBRequestHandlerModel.hpp.

m_num_requests_bad

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_bad { 0 }

protected

Definition at line 283 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_requests_delayed

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_delayed { 0 }

protected

Definition at line 285 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_requests_found

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_found { 0 }

protected

Definition at line 282 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_requests_old_window

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_old_window { 0 }

protected

Definition at line 284 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_requests_timed_out

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_timed_out { 0 }

protected

Definition at line 287 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_num_requests_uncategorized

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_num_requests_uncategorized { 0 }

protected

Definition at line 286 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_occupancy

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_occupancy

protected

Definition at line 281 of file SNBRequestHandlerModel.hpp.

m_oldest_timestamp

template<class ReadoutType , class LatencyBufferType >

std::atomic<uint64_t> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_oldest_timestamp { 0 }

protected

Definition at line 296 of file SNBRequestHandlerModel.hpp.

{ 0 };         // NOLINT(build/unsigned)

m_output_file

template<class ReadoutType , class LatencyBufferType >

std::string dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_output_file

protected

Definition at line 268 of file SNBRequestHandlerModel.hpp.

m_payloads_written

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_payloads_written { 0 }

protected

Definition at line 292 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_periodic_data_transmission_ms

template<class ReadoutType , class LatencyBufferType >

uint32_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_periodic_data_transmission_ms = 0

protected

Definition at line 273 of file SNBRequestHandlerModel.hpp.

m_periodic_transmission_thread

template<class ReadoutType , class LatencyBufferType >

utilities::ReusableThread dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_periodic_transmission_thread

protected

Definition at line 233 of file SNBRequestHandlerModel.hpp.

m_pop_counter

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_pop_counter

protected

Definition at line 277 of file SNBRequestHandlerModel.hpp.

m_pop_list

template<class ReadoutType , class LatencyBufferType >

std::set<uint64_t> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_pop_list

protected

Definition at line 264 of file SNBRequestHandlerModel.hpp.

m_pop_list_mutex

template<class ReadoutType , class LatencyBufferType >

std::mutex dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_pop_list_mutex

protected

Definition at line 263 of file SNBRequestHandlerModel.hpp.

m_pop_reqs

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_pop_reqs

protected

Definition at line 279 of file SNBRequestHandlerModel.hpp.

m_pops_count

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_pops_count

protected

Definition at line 280 of file SNBRequestHandlerModel.hpp.

m_recording

template<class ReadoutType , class LatencyBufferType >

std::atomic<bool> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_recording = false

protected

Definition at line 258 of file SNBRequestHandlerModel.hpp.

m_recording_configured

template<class ReadoutType , class LatencyBufferType >

bool dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_recording_configured = false

protected

Definition at line 270 of file SNBRequestHandlerModel.hpp.

m_recording_thread

template<class ReadoutType , class LatencyBufferType >

utilities::ReusableThread dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_recording_thread

protected

Definition at line 230 of file SNBRequestHandlerModel.hpp.

m_request_counter

template<class ReadoutType , class LatencyBufferType >

std::map<dfmessages::DataRequest, int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_request_counter

protected

Definition at line 236 of file SNBRequestHandlerModel.hpp.

m_request_handler_thread_pool

template<class ReadoutType , class LatencyBufferType >

std::unique_ptr<boost::asio::thread_pool> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_request_handler_thread_pool

protected

Definition at line 247 of file SNBRequestHandlerModel.hpp.

m_request_timeout_ms

template<class ReadoutType , class LatencyBufferType >

int dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_request_timeout_ms

private

Definition at line 307 of file SNBRequestHandlerModel.hpp.

m_requests_running

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_requests_running = 0

protected

Definition at line 242 of file SNBRequestHandlerModel.hpp.

m_response_time_acc

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_response_time_acc { 0 }

protected

Definition at line 289 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_response_time_max

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_response_time_max { 0 }

protected

Definition at line 291 of file SNBRequestHandlerModel.hpp.

{ 0 };

m_response_time_min

template<class ReadoutType , class LatencyBufferType >

std::atomic<int> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_response_time_min { std::numeric_limits<int>::max() }

protected

Definition at line 290 of file SNBRequestHandlerModel.hpp.

{ std::numeric_limits<int>::max() };

m_run_marker

template<class ReadoutType , class LatencyBufferType >

std::atomic<bool> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_run_marker = false

protected

Definition at line 255 of file SNBRequestHandlerModel.hpp.

m_sourceid

template<class ReadoutType , class LatencyBufferType >

daqdataformats::SourceID dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_sourceid

protected

Definition at line 266 of file SNBRequestHandlerModel.hpp.

m_stream_buffer_size

template<class ReadoutType , class LatencyBufferType >

size_t dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_stream_buffer_size = 0

protected

Definition at line 269 of file SNBRequestHandlerModel.hpp.

m_t0

template<class ReadoutType , class LatencyBufferType >

std::chrono::time_point<std::chrono::high_resolution_clock> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_t0

protected

Definition at line 252 of file SNBRequestHandlerModel.hpp.

m_waiting_queue_thread

template<class ReadoutType , class LatencyBufferType >

std::thread dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_waiting_queue_thread

protected

Definition at line 257 of file SNBRequestHandlerModel.hpp.

m_waiting_requests

template<class ReadoutType , class LatencyBufferType >

std::vector<RequestElement> dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_waiting_requests

protected

Definition at line 243 of file SNBRequestHandlerModel.hpp.

m_waiting_requests_lock

template<class ReadoutType , class LatencyBufferType >

std::mutex dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_waiting_requests_lock

protected

Definition at line 244 of file SNBRequestHandlerModel.hpp.

m_warn_about_empty_buffer

template<class ReadoutType , class LatencyBufferType >

bool dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_warn_about_empty_buffer = true

protected

Definition at line 272 of file SNBRequestHandlerModel.hpp.

m_warn_on_timeout

template<class ReadoutType , class LatencyBufferType >

bool dunedaq::snbmodules::SNBRequestHandlerModel< ReadoutType, LatencyBufferType >::m_warn_on_timeout = true

protected

Definition at line 271 of file SNBRequestHandlerModel.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/snbmodules/include/snbmodules/readout/SNBRequestHandlerModel.hpp
• /github/workspace/dunedaq/sourcecode/snbmodules/include/snbmodules/readout/detail/SNBRequestHandlerModel.hxx