dunedaq::datahandlinglibs::FixedRateQueueModel< T > Class Template Reference

#include <FixedRateQueueModel.hpp>

Inheritance diagram for dunedaq::datahandlinglibs::FixedRateQueueModel< T >:

Collaboration diagram for dunedaq::datahandlinglibs::FixedRateQueueModel< T >:

Public Member Functions
	FixedRateQueueModel ()
	FixedRateQueueModel (uint32_t size)
IterableQueueModel< T >::Iterator	lower_bound (T &element, bool with_errors=false)
Public Member Functions inherited from dunedaq::datahandlinglibs::BinarySearchQueueModel< T >
	BinarySearchQueueModel ()
	BinarySearchQueueModel (uint32_t size)
IterableQueueModel< T >::Iterator	lower_bound (T &element, bool=false)
Public Member Functions inherited from dunedaq::datahandlinglibs::IterableQueueModel< T >
	IterableQueueModel (const IterableQueueModel &)=delete
IterableQueueModel &	operator= (const IterableQueueModel &)=delete
	IterableQueueModel ()
	IterableQueueModel (std::size_t size)
	IterableQueueModel (std::size_t size, bool numa_aware=false, uint8_t numa_node=0, bool intrinsic_allocator=false, std::size_t alignment_size=0)
	~IterableQueueModel ()
void	free_memory ()
void	allocate_memory (std::size_t size, bool numa_aware, uint8_t numa_node=0, bool intrinsic_allocator=false, std::size_t alignment_size=0)
void	allocate_memory (std::size_t size) override
void	prefill_task ()
void	force_pagefault ()
bool	write (T &&record) override
	Move referenced object into LB.
bool	read (T &record) override
	Move object from LB to referenced.
void	popFront ()
void	pop (std::size_t x)
	Pop specified amount of elements from LB.
bool	isEmpty () const
bool	isFull () const
std::size_t	occupancy () const override
	Occupancy of LB.
std::size_t	size () const
std::size_t	capacity () const
const T *	front () override
	Write referenced object into LB without moving it.
const T *	back () override
	Get pointer to the back of the LB.
T *	start_of_buffer ()
T *	end_of_buffer ()
void	conf (const appmodel::LatencyBuffer *cfg) override
	Configure the LB.
void	scrap (const appfwk::DAQModule::CommandData_t &) override
	Unconfigure the LB.
void	flush () override
	Flush all elements from the latency buffer.
std::size_t	get_alignment_size ()
Iterator	begin ()
Iterator	end ()
Public Member Functions inherited from dunedaq::datahandlinglibs::LatencyBufferConcept< T >
	LatencyBufferConcept ()
virtual	~LatencyBufferConcept ()
	LatencyBufferConcept (const LatencyBufferConcept &)=delete
	LatencyBufferConcept is not copy-constructible.
LatencyBufferConcept &	operator= (const LatencyBufferConcept &)=delete
	LatencyBufferConcept is not copy-assginable.
	LatencyBufferConcept (LatencyBufferConcept &&)=delete
	LatencyBufferConcept is not move-constructible.
LatencyBufferConcept &	operator= (LatencyBufferConcept &&)=delete
	LatencyBufferConcept is not move-assignable.
virtual void	allocate_memory (size_t)=0
	Whether or not the buffer is allocatable. false by default.
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

Additional Inherited Members
Public Types inherited from dunedaq::datahandlinglibs::IterableQueueModel< T >
typedef T	value_type
Public Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string
Static Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept
Protected Member Functions inherited from dunedaq::datahandlinglibs::IterableQueueModel< T >
virtual void	generate_opmon_data () override
template<class... Args>
bool	write_ (Args &&... recordArgs)
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 inherited from dunedaq::datahandlinglibs::IterableQueueModel< T >
std::atomic< int >	overflow_ctr { 0 }
bool	numa_aware_
uint8_t	numa_node_
bool	intrinsic_allocator_
std::size_t	alignment_size_
bool	invalid_configuration_requested_
std::string	prefiller_name_ {"lbpfn"}
std::mutex	prefill_mutex_
std::condition_variable	prefill_cv_
bool	prefill_ready_
bool	prefill_done_
std::thread	ptrlogger
char	pad0_ [folly::hardware_destructive_interference_size]
uint32_t	size_
T *	records_
std::atomic< unsigned int >	readIndex_
std::atomic< unsigned int >	writeIndex_
char	pad1_ [folly::hardware_destructive_interference_size - sizeof(writeIndex_)]

Detailed Description

template<class T>
class dunedaq::datahandlinglibs::FixedRateQueueModel< T >

Definition at line 22 of file FixedRateQueueModel.hpp.

Constructor & Destructor Documentation

FixedRateQueueModel() [1/2]

template<class T>

dunedaq::datahandlinglibs::FixedRateQueueModel< T >::FixedRateQueueModel ( )

inline

Definition at line 25 of file FixedRateQueueModel.hpp.

    : BinarySearchQueueModel<T>()
  {}

FixedRateQueueModel() [2/2]

template<class T>

dunedaq::datahandlinglibs::FixedRateQueueModel< T >::FixedRateQueueModel ( uint32_t size )

inlineexplicit

Definition at line 29 of file FixedRateQueueModel.hpp.

    : BinarySearchQueueModel<T>(size)
  {}

Member Function Documentation

lower_bound()

template<typename T>

IterableQueueModel< T >::Iterator dunedaq::datahandlinglibs::FixedRateQueueModel< T >::lower_bound	(	T &	element,
		bool	with_errors = false )

Definition at line 8 of file FixedRateQueueModel.hxx.

{
  if (with_errors) {
    return BinarySearchQueueModel<T>::lower_bound(element, with_errors);
  }
  uint64_t timestamp = element.get_timestamp(); // NOLINT(build/unsigned)
  unsigned int start_index =
    IterableQueueModel<T>::readIndex_.load(std::memory_order_relaxed); // NOLINT(build/unsigned)
  size_t occupancy_guess = IterableQueueModel<T>::occupancy();
  uint64_t last_ts = IterableQueueModel<T>::records_[start_index].get_timestamp(); // NOLINT(build/unsigned)
  uint64_t newest_ts =                                                                   // NOLINT(build/unsigned)
    last_ts +
    occupancy_guess * T::expected_tick_difference * IterableQueueModel<T>::records_[start_index].get_num_frames();
  size_t n_frames = IterableQueueModel<T>::records_[start_index].get_num_frames();
  
  if (last_ts > timestamp || timestamp > newest_ts) {
    return IterableQueueModel<T>::end();
  }
 
  int64_t time_tick_diff = (timestamp - last_ts);
 
  //if we are aligned on a n_frame boundary, 
  uint32_t num_element_offset = time_tick_diff/T::expected_tick_difference/n_frames; // NOLINT(build/unsigned)
  uint32_t target_index = start_index + num_element_offset; // NOLINT(build/unsigned)
 
  //if we aren't perfectly aligned on a n_frames boundary, move us up so we satisfy normal lower_bound rules
  if(time_tick_diff%(T::expected_tick_difference*n_frames)!=0) ++target_index;
  
  if (target_index >= IterableQueueModel<T>::size_) {
    target_index -= IterableQueueModel<T>::size_;
  }
 
  return typename IterableQueueModel<T>::Iterator(*this, target_index);
}

---

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

• /github/workspace/dunedaq/sourcecode/datahandlinglibs/include/datahandlinglibs/models/FixedRateQueueModel.hpp
• /github/workspace/dunedaq/sourcecode/datahandlinglibs/include/datahandlinglibs/models/detail/FixedRateQueueModel.hxx