#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 nlohmann::json &) 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.

26 : BinarySearchQueueModel<T>()

27 {}

dunedaq::datahandlinglibs::BinarySearchQueueModel::BinarySearchQueueModel

BinarySearchQueueModel()

Definition BinarySearchQueueModel.hpp:25

◆ FixedRateQueueModel() [2/2]

template<class T >

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

inlineexplicit

Definition at line 29 of file FixedRateQueueModel.hpp.

30 : BinarySearchQueueModel<T>(size)

31 {}

dunedaq::datahandlinglibs::IterableQueueModel::size

std::size_t size() const

Definition IterableQueueModel.hpp:213

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