tpglibs::AVXRunSumProcessor Class Reference

AVX signal processor: Calculates the running sum of the signal. More...

#include <AVXRunSumProcessor.hpp>

Inheritance diagram for tpglibs::AVXRunSumProcessor:

Collaboration diagram for tpglibs::AVXRunSumProcessor:

Public Member Functions
__m256i	process (const __m256i &signal) override
	Calculate and store the running sum.
void	configure (const nlohmann::json &config, const int16_t *plane_numbers) override
	Configures the R factor and S factor according to plane.
Public Member Functions inherited from tpglibs::AVXProcessor
Public Member Functions inherited from tpglibs::AbstractProcessor< __m256i >
virtual	~AbstractProcessor ()=default
ProcessorInternalStateBufferManager< __m256i > *	_get_internal_state_buffer_manager ()
ProcessorInternalStateNameRegistry< __m256i > *	_get_internal_state_name_registry ()
virtual void	configure_internal_state_collection (const nlohmann::json &config)
	Configure common internal state collection parameters.
void	set_next_processor (std::shared_ptr< AbstractProcessor< __m256i > > next_processor)
	Setter for next processor.
std::shared_ptr< AbstractProcessor< __m256i > >	get_next_processor ()
	Getter for next processor.
virtual std::vector< std::string >	get_requested_internal_state_names () const
	Get the names of requested internal states (delegates to registry).
virtual ProcessorMetricArray< std::array< int16_t, 16 > >	read_internal_states_as_integer_array ()

Private Attributes
__m256i	m_memory_factor
	The R factor in the model equation.
__m256i	m_scale_factor
	The S factor in the model equation.
__m256i	m_running_sum
	The RS in the model equation.
__m256i	m_scale_divisor
	The divisor for the S factor.
__m256i	m_memory_divisor
	The divisor for the R factor.

Additional Inherited Members
Public Types inherited from tpglibs::AbstractProcessor< __m256i >
using	signal_type_t
	Signal type to process on. General __m256i.
Protected Attributes inherited from tpglibs::AbstractProcessor< __m256i >
ProcessorInternalStateBufferManager< __m256i >	m_internal_state_buffer_manager
ProcessorInternalStateNameRegistry< __m256i >	m_internal_state_name_registry
std::atomic< uint64_t >	m_samples
bool	m_collect_internal_state_flag
uint64_t	m_sample_period

Detailed Description

AVX signal processor: Calculates the running sum of the signal.

Calculates the running sum of the signal with some factors. This tries to model the following equation: RS = R * RS + S * signal, where

• RS is the on-going running sum,
• R is the memory factor of the on-going running sum,
• S is the scale factor for the incoming signal to avoid overflowing,
• signal is the incoming signal.

Definition at line 26 of file AVXRunSumProcessor.hpp.

Member Function Documentation

configure()

void tpglibs::AVXRunSumProcessor::configure ( const nlohmann::json & config, const int16_t * plane_numbers )

overridevirtual

Configures the R factor and S factor according to plane.

Parameters

config	JSON of the R and S factors to use per plane.
plane_numbers	Array of plane numbers. Gives the channels to apply the R and S factors.

Implements tpglibs::AbstractProcessor< __m256i >.

Definition at line 15 of file AVXRunSumProcessor.cpp.

                                                                                           {
  // Configure common metric collection parameters
  // Register pointers to the ACTUAL member variables, not copies
  // Use shared_ptr with no-op deleter to avoid double-free
  m_internal_state_name_registry.register_internal_state("r", 
    std::shared_ptr<__m256i>(&m_memory_factor, [](auto*){}));
  m_internal_state_name_registry.register_internal_state("s", 
    std::shared_ptr<__m256i>(&m_scale_factor, [](auto*){}));
  m_internal_state_name_registry.register_internal_state("rs", 
    std::shared_ptr<__m256i>(&m_running_sum, [](auto*){}));
    
  configure_internal_state_collection(config);
 
  int16_t memory_factors[16];
  int16_t plane_memory_factors[3] = {config["memory_factor_plane0"],
                                     config["memory_factor_plane1"],
                                     config["memory_factor_plane2"]};
  int16_t memory_divisors[16];
  int16_t plane_memory_divisors[3] = {config["memory_divisor_plane0"],
                                      config["memory_divisor_plane1"],
                                      config["memory_divisor_plane2"]};
  int16_t scale_factors[16];
  int16_t plane_scale_factors[3]  = {config["scale_factor_plane0"],
                                     config["scale_factor_plane1"],
                                     config["scale_factor_plane2"]};
  int16_t scale_divisors[16];
  int16_t plane_scale_divisors[3] = {config["scale_divisor_plane0"],
                                     config["scale_divisor_plane1"],
                                     config["scale_divisor_plane2"]};
 
  for (int i = 0; i < 16; i++) {
    memory_factors[i] = plane_memory_factors[plane_numbers[i]];
    memory_divisors[i] = 0x7FFF / plane_memory_divisors[plane_numbers[i]];  // Need to adjust for AVX2 usage.
    scale_factors[i] = plane_scale_factors[plane_numbers[i]];
    scale_divisors[i] = 0x7FFF / plane_scale_divisors[plane_numbers[i]];  // Need to adjust for AVX2 usage.
  }
 
  m_memory_factor = _mm256_lddqu_si256(reinterpret_cast<__m256i*>(memory_factors));
  m_memory_divisor = _mm256_lddqu_si256(reinterpret_cast<__m256i*>(memory_divisors));
  m_scale_factor = _mm256_lddqu_si256(reinterpret_cast<__m256i*>(scale_factors));
  m_scale_divisor = _mm256_lddqu_si256(reinterpret_cast<__m256i*>(scale_divisors));
}

process()

__m256i tpglibs::AVXRunSumProcessor::process ( const __m256i & signal )

overridevirtual

Calculate and store the running sum.

Parameters

signal

The input signal to process on.

Returns

The calculated running sum.

Reimplemented from tpglibs::AVXProcessor.

Definition at line 58 of file AVXRunSumProcessor.cpp.

                                                         {
  // Update sample counter and write internal states to buffer for harvesting
  m_samples++;
  if (m_collect_internal_state_flag && (m_samples % m_sample_period == 0)) {
    m_internal_state_buffer_manager.write_to_active_buffer();
  }
 
  __m256i scaled_rs = _mm256_mulhrs_epi16(m_running_sum, m_memory_divisor);
  scaled_rs = _mm256_mullo_epi16(scaled_rs, m_memory_factor);
 
  __m256i scaled_signal = _mm256_mulhrs_epi16(signal, m_scale_divisor);
  scaled_signal = _mm256_mullo_epi16(scaled_signal, m_scale_factor);
 
  m_running_sum = _mm256_adds_epi16(scaled_rs, scaled_signal);
  return AVXProcessor::process(m_running_sum);
}

Member Data Documentation

m_memory_divisor

__m256i tpglibs::AVXRunSumProcessor::m_memory_divisor

private

The divisor for the R factor.

Definition at line 40 of file AVXRunSumProcessor.hpp.

m_memory_factor

__m256i tpglibs::AVXRunSumProcessor::m_memory_factor

private

The R factor in the model equation.

Definition at line 28 of file AVXRunSumProcessor.hpp.

m_running_sum

__m256i tpglibs::AVXRunSumProcessor::m_running_sum

private

The RS in the model equation.

Definition at line 34 of file AVXRunSumProcessor.hpp.

m_scale_divisor

__m256i tpglibs::AVXRunSumProcessor::m_scale_divisor

private

The divisor for the S factor.

Definition at line 37 of file AVXRunSumProcessor.hpp.

m_scale_factor

__m256i tpglibs::AVXRunSumProcessor::m_scale_factor

private

The S factor in the model equation.

Definition at line 31 of file AVXRunSumProcessor.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/tpglibs/include/tpglibs/AVXRunSumProcessor.hpp
• /github/workspace/dunedaq/sourcecode/tpglibs/src/AVXRunSumProcessor.cpp