AbstractProcessor.hpp

Go to the documentation of this file.

 
#ifndef TPGLIBS_ABSTRACTPROCESSOR_HPP_
#define TPGLIBS_ABSTRACTPROCESSOR_HPP_
 
#include <cstdint>
#include <memory>
#include <nlohmann/json.hpp>
 
#include "tpglibs/ProcessorMetricArray.hpp"
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
#include "tpglibs/ProcessorInternalStateBufferManager.hpp"
#include "tpglibs/ProcessorInternalStateNameRegistry.hpp"
#endif
 
namespace tpglibs {

template<class T>
class AbstractProcessor
{
  std::shared_ptr<AbstractProcessor<T>> m_next_processor;
 
protected:
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
  ProcessorInternalStateBufferManager<T> m_internal_state_buffer_manager;
  ProcessorInternalStateNameRegistry<T> m_internal_state_name_registry;
 
  // Sample counting and collection control
  std::atomic<uint64_t> m_samples{ 0 };
  bool m_collect_internal_state_flag{ false };
  uint64_t m_sample_period{ 1 };
#endif
 
public:
  using signal_type_t = T;
 
  virtual ~AbstractProcessor() = default;
 
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
  ProcessorInternalStateBufferManager<T>* _get_internal_state_buffer_manager()
  {
    return &m_internal_state_buffer_manager;
  }
 
  ProcessorInternalStateNameRegistry<T>* _get_internal_state_name_registry() { return &m_internal_state_name_registry; }

  virtual void configure_internal_state_collection(const nlohmann::json& config)
  {
    m_collect_internal_state_flag = config.value("metric_collect_toggle_state", false);
    m_sample_period = config.value("metric_collect_time_sample_period", 1);
 
    if (m_collect_internal_state_flag) {
      if (config.contains("requested_internal_states")) {
        m_internal_state_name_registry.parse_requested_internal_state_items(config["requested_internal_states"]);
      } else {
        m_internal_state_name_registry.parse_requested_internal_state_items("");
      }
 
      // Only configure if we actually have states to collect
      auto num_items = m_internal_state_name_registry.get_number_of_requested_internal_states();
      if (num_items > 0) {
        m_internal_state_buffer_manager.configure_from_registry(&m_internal_state_name_registry);
      }
    }
  }
#else
  virtual void configure_internal_state_collection(const nlohmann::json& /* config */) {}
#endif

  virtual void configure(const nlohmann::json& config, const int16_t* plane_numbers) = 0;

  void set_next_processor(std::shared_ptr<AbstractProcessor<T>> next_processor) { m_next_processor = next_processor; }

  std::shared_ptr<AbstractProcessor<T>> get_next_processor() { return m_next_processor; }

  virtual T process(const T& signal)
  {
    if (m_next_processor) {
      return m_next_processor->process(signal);
    }
    return signal;
  }

  virtual std::vector<std::string> get_requested_internal_state_names() const
  {
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
    return m_internal_state_name_registry.get_names_of_requested_internal_states();
#else
    return {};
#endif
  }
 
  virtual ProcessorMetricArray<std::array<int16_t, 16>> read_internal_states_as_integer_array()
  {
#ifdef TPGLIBS_ENABLE_STATE_MONITORING
    return m_internal_state_buffer_manager.switch_buffer_and_read_casted();
#else
    return { nullptr, 0 };
#endif
  }
};
 
} // namespace tpglibs
 
#endif // TPGLIBS_ABSTRACTPROCESSOR_HPP_