tpglibs::TPGenerator Class Reference

TPG driving class. More...

#include <TPGenerator.hpp>

Public Member Functions
void	configure (const std::vector< std::pair< std::string, nlohmann::json > > &configs, const std::vector< std::pair< dunedaq::trgdataformats::channel_t, int16_t > > channel_plane_numbers, const float sample_tick_difference)
	Setup and configure the AVX pipelines.
void	reset ()
	Remove all pipelines and reset member variables to default state.
void	set_sot_minima (const std::vector< uint16_t > &sot_minima)
	Set the minimum samples over threshold for a TP according to plane.
std::vector< std::pair< std::shared_ptr< AbstractProcessor< __m256i > >, int > >	get_all_processor_references_with_pipeline_index ()
	Return reference to all processors, under all pipelines, where the index of the pipeline is tagged along with the reference.
template<typename T >
std::vector< dunedaq::trgdataformats::TriggerPrimitive >	operator() (const T *frame)
	Driving function for the TPG.

Private Member Functions
__m256i	expand_frame (const __m256i &regi)
__m256i	old_expand_frame (const __m256i &regi)
	Expansion from 14-bit signals to 16-bit.

Private Attributes
bool	m_configured {false}
uint8_t	m_num_pipelines = 0
std::vector< AVXPipeline >	m_tpg_pipelines
float	m_sample_tick_difference = 0
std::vector< uint16_t >	m_sot_minima {1,1,1}

Static Private Attributes
static const uint8_t	m_num_channels_per_pipeline = 16

Detailed Description

TPG driving class.

This is the interface that receives raw data frames to process and outputs the TPs accordingly.

Definition at line 31 of file TPGenerator.hpp.

Member Function Documentation

configure()

void tpglibs::TPGenerator::configure	(	const std::vector< std::pair< std::string, nlohmann::json > > &	configs,
		const std::vector< std::pair< dunedaq::trgdataformats::channel_t, int16_t > >	channel_plane_numbers,
		const float	sample_tick_difference )

Setup and configure the AVX pipelines.

Parameters

configs	A vector of pairs: AVX pipeline to use and its configuration.
channel_plane_numbers	A vector of channel numbers and their plane numbers.
sample_tick_difference	Number of ticks between time samples in expected data frames.

Definition at line 14 of file TPGenerator.cpp.

                                                           {
  if (m_configured) {
    reset();
  }
 
  m_num_pipelines = channel_plane_numbers.size() / m_num_channels_per_pipeline;
  m_sample_tick_difference = sample_tick_difference;
 
  for (int p = 0; p < m_num_pipelines; p++) {
    AVXPipeline new_pipe = AVXPipeline();
    auto begin_channel_plane = channel_plane_numbers.begin() + p*m_num_channels_per_pipeline;
    auto end_channel_plane = begin_channel_plane + m_num_channels_per_pipeline;
    new_pipe.configure(configs, std::vector<std::pair<dunedaq::trgdataformats::channel_t, int16_t>>(begin_channel_plane, end_channel_plane));
    new_pipe.set_sot_minima(m_sot_minima);
    m_tpg_pipelines.push_back(new_pipe);
  }
 
  m_configured = true;
}

expand_frame()

__m256i tpglibs::TPGenerator::expand_frame ( const __m256i & regi )

private

Definition at line 63 of file TPGenerator.cpp.

                                             {
  // Refer to the diagram and documentation on frame expansion for details.
 
  // Prepare even (2,4,6,8), odd (1,3,5,7) rows in 64-bit sense.
  __m256i odd  = _mm256_permutevar8x32_epi32(regi, _mm256_setr_epi32(1, 0, 1, 2, 3, 4, 5, 6));
 
  // Shift into place.
  __m256i even = _mm256_sllv_epi64(regi, _mm256_setr_epi64x(6, 14, 22, 30));
  odd  = _mm256_srlv_epi64(odd, _mm256_setr_epi64x(30, 22, 14, 6));
 
  // Everything is center aligned in 32-bit. Mask and right-align the right side.
  __m256i both  = _mm256_blend_epi32(even, odd, 0b01010101);
  __m256i right = _mm256_and_si256(_mm256_set1_epi32(0xFFFFu), both);
  __m256i left  = _mm256_and_si256(_mm256_set1_epi32(0x3FFF0000u), both);
 
  right = _mm256_srli_epi32(right, 2);
  return _mm256_or_si256(left, right);
}

get_all_processor_references_with_pipeline_index()

std::vector< std::pair< std::shared_ptr< AbstractProcessor< __m256i > >, int > > tpglibs::TPGenerator::get_all_processor_references_with_pipeline_index

(

)

Return reference to all processors, under all pipelines, where the index of the pipeline is tagged along with the reference.

Returns

A vector of all processor references.

Definition at line 36 of file TPGenerator.cpp.

                                                                                                                                 {
  std::vector<std::pair<std::shared_ptr<AbstractProcessor<__m256i>>, int>> processor_references;
 
  for (int pipeline_id = 0; pipeline_id < m_num_pipelines; ++pipeline_id) {
    for (auto& processor : m_tpg_pipelines[pipeline_id].get_all_processor_references()) {
      processor_references.push_back(std::make_pair(processor, pipeline_id));
    }
  }
  return processor_references;
}

old_expand_frame()

__m256i tpglibs::TPGenerator::old_expand_frame ( const __m256i & regi )

private

Expansion from 14-bit signals to 16-bit.

Definition at line 83 of file TPGenerator.cpp.

                                                 {
  // Refer to the diagram and documentation on frame expansion for details.
 
  // Rearrange original with row 3 doubled.
  __m256i idx = _mm256_set_epi32(6, 5, 4, 3, 3, 2, 1, 0);
  __m256i shuf1 = _mm256_permutevar8x32_epi32(regi, idx);
 
  // Left shift each row.
  __m256i count = _mm256_set_epi32(12, 8, 4, 0, 14, 10, 6, 2);
  __m256i high_half = _mm256_sllv_epi32(shuf1, count);
  high_half = _mm256_and_si256(high_half, _mm256_set1_epi32(0x3FFF0000u));  // Mask out the low half.
 
  // Left shift for low half later.
  count = _mm256_set_epi32(10, 6, 2, 0, 12, 8, 4, 0);
  __m256i shift2 = _mm256_sllv_epi32(shuf1, count);
 
  // Rearrange original and doubled rows 2 and 0.
  idx = _mm256_set_epi32(5, 4, 3, 2, 2, 1, 0, 0);
  __m256i shuf2 = _mm256_permutevar8x32_epi32(regi, idx);
 
  // Right shift each row.
  count = _mm256_set_epi32(22, 26, 30, 0, 20, 24, 28, 0);
  __m256i shift3 = _mm256_srlv_epi32(shuf2, count);
 
  // "Complete" the low half. Still more.
  __m256i low_half = _mm256_or_si256(shift2, shift3);
  low_half = _mm256_and_si256(low_half, _mm256_set1_epi32(0x3FFFu)); // Mask out the high half.
 
  // Combine halves and clear space for an odd entry.
  __m256i both = _mm256_or_si256(low_half, high_half);
  both = _mm256_andnot_si256(_mm256_set_epi32(0, 0, 0, 0xFFFFu, 0, 0, 0, 0), both);
 
  // There is a specific 16-bit entry that needs special handling.
  // Align it.
  __m256i shift4 = _mm256_srli_epi32(regi, 18);
  // Mask it.
  shift4 = _mm256_and_si256(_mm256_set_epi32(0, 0x3FFFu, 0, 0, 0, 0, 0, 0), shift4);
 
  // Permute into the right spot
  idx = _mm256_set_epi32(0, 0, 0, 6, 0, 0, 0, 0);
  __m256i shuf3 = _mm256_permutevar8x32_epi32(shift4, idx);
 
  // Add it in.
  both = _mm256_or_si256(both, shuf3);
  return both;
}

operator()()

template<typename T >

std::vector< dunedaq::trgdataformats::TriggerPrimitive > tpglibs::TPGenerator::operator() ( const T * frame )

inline

Driving function for the TPG.

This function receives the frames, expands, sends down AVX pipelines, and returns TPs that were generated.

Parameters

frame

A data frame to process and generate TPs from.

Returns

A vector of TPs.

Definition at line 80 of file TPGenerator.hpp.

                                                                                {
      // Max number of TPs for a channel: number of time samples / 2.
      std::vector<dunedaq::trgdataformats::TriggerPrimitive> tp_aggr;
      tp_aggr.reserve(T::s_num_channels * T::s_time_samples_per_frame / 2);
 
      const typename T::word_t (*words_ptr)[T::s_bits_per_adc] = frame->adc_words;
      const uint64_t timestamp = frame->get_timestamp();
 
      const int register_alignment = T::s_bits_per_adc * m_num_channels_per_pipeline;
      // Loop in time.
      for (int t = 0; t < T::s_time_samples_per_frame; t++) {
        const typename T::word_t *time_sample = *(words_ptr + t);
        char* cursor = (char*) time_sample; // Need to walk in terms of bytes/bits.
 
        // Loop in pipelines.
        for (int p = 0; p < m_num_pipelines; p++) {
          if (p == m_num_pipelines - 1)
            cursor -= 4; // Take a step of 32 bit backwards for the last sub-frame.
 
          __m256i regi = _mm256_lddqu_si256((__m256i*)cursor);
 
          if (p == m_num_pipelines - 1) // Permute the row order to use the same operation.
            regi = _mm256_permutevar8x32_epi32(regi, _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 0));
 
          __m256i expanded_subframe = expand_frame(regi);
          std::vector<dunedaq::trgdataformats::TriggerPrimitive> tps = m_tpg_pipelines[p].process(expanded_subframe);
 
          for (auto tp : tps) {
            tp.time_start = static_cast<int64_t>((t - tp.samples_over_threshold) * m_sample_tick_difference) + timestamp;
            tp_aggr.push_back(tp);
          }
          cursor += register_alignment / 8; // Numerator is in bits. Need bytes.
        }
      }
 
      return tp_aggr;
    }

reset()

void tpglibs::TPGenerator::reset

(

)

Remove all pipelines and reset member variables to default state.

Definition at line 48 of file TPGenerator.cpp.

                   {
  m_num_pipelines = 0;
  m_tpg_pipelines.clear();
  m_sample_tick_difference = 0;
  m_sot_minima = {1, 1, 1};
  m_configured = false;
}

set_sot_minima()

void tpglibs::TPGenerator::set_sot_minima

(

const std::vector< uint16_t > &

sot_minima

)

Set the minimum samples over threshold for a TP according to plane.

Parameters

sot_minima

TPs from plane i will have at least sot_minima[i] value for its samples_over_threshold.

Definition at line 57 of file TPGenerator.cpp.

                                                                 {
  m_sot_minima = sot_minima;
}

Member Data Documentation

m_configured

bool tpglibs::TPGenerator::m_configured {false}

private

Definition at line 33 of file TPGenerator.hpp.

{false};

m_num_channels_per_pipeline

const uint8_t tpglibs::TPGenerator::m_num_channels_per_pipeline = 16

staticprivate

Definition at line 32 of file TPGenerator.hpp.

m_num_pipelines

uint8_t tpglibs::TPGenerator::m_num_pipelines = 0

private

Definition at line 34 of file TPGenerator.hpp.

m_sample_tick_difference

float tpglibs::TPGenerator::m_sample_tick_difference = 0

private

Definition at line 36 of file TPGenerator.hpp.

m_sot_minima

std::vector<uint16_t> tpglibs::TPGenerator::m_sot_minima {1,1,1}

private

Definition at line 37 of file TPGenerator.hpp.

{1,1,1};  // Defaults to 1 for all planes.

m_tpg_pipelines

std::vector<AVXPipeline> tpglibs::TPGenerator::m_tpg_pipelines

private

Definition at line 35 of file TPGenerator.hpp.

---

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

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