TPGenerator.hpp

Go to the documentation of this file.

 
#ifndef TPGLIBS_TPGENERATOR_HPP_
#define TPGLIBS_TPGENERATOR_HPP_
 
#include <memory>
#include "tpglibs/ProcessorMetricCollector.hpp"
#include "tpglibs/AVXPipeline.hpp"
 
#include "trgdataformats/Types.hpp"
 
#include <utility>
#include <unordered_map>
 
 
namespace tpglibs {
 
class TPGenerator {
  static const uint8_t m_num_channels_per_pipeline = 16; // AVX2 with int16 data samples allows us to process 16 channels.
  uint8_t m_num_pipelines = 0;  // Gets set inside configure.
  std::vector<AVXPipeline> m_tpg_pipelines;
  int m_sample_tick_difference;
  std::vector<uint16_t> m_sot_minima{1,1,1};  // Defaults to 1 for all planes.
  std::shared_ptr<ProcessorMetricCollector<__m256i>> m_processor_metric_collector_ptr {nullptr};
  bool m_tpg_metric_collect_enabled {false};
 
  public:
    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 int sample_tick_difference);
 
    void set_sot_minima(const std::vector<uint16_t>& sot_minima);
 
    void* get_processor_metric_collector();
 
    std::shared_ptr<ProcessorMetricCollector<__m256i>>  get_processor_metric_collector_ptr();
 
    void set_metric_collector_enable_state(bool state) {
      m_tpg_metric_collect_enabled = state;
    }
 
    bool get_metric_collector_enable_state() {
      return m_tpg_metric_collect_enabled;
    }
 
    void signal_metric_collection();
 
    std::unordered_map<dunedaq::trgdataformats::channel_t, std::vector<std::pair<std::string, int16_t>>> get_processor_metrics();
 
    void free_metric_collector() {
      if (m_processor_metric_collector_ptr != nullptr) {
        m_processor_metric_collector_ptr->stop();
        
        m_processor_metric_collector_ptr.reset();
      }
    }
 
    template <typename T>
    std::vector<dunedaq::trgdataformats::TriggerPrimitive> operator()(const T* frame) {
      // 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 = (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;
    }
 
  private:
    __m256i expand_frame(const __m256i& regi); 
    __m256i old_expand_frame(const __m256i& regi); 
};
 
} // namespace tpglibs
 
#endif // TPGLIBS_TPGENERATOR_HPP_