ddtMonitorSamplesDialog.hpp

Go to the documentation of this file.

 
#ifndef DDT_DATAVISUALISATION_DDTDIALOGS_MONITORSAMPLES_HPP
#define DDT_DATAVISUALISATION_DDTDIALOGS_MONITORSAMPLES_HPP
 
#include <iomanip>
#include <iostream>
#include <optional>
#include <QtWidgets>
 
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>
#include <boost/accumulators/statistics/stats.hpp>
 
#include "ddt/dialogs/ddtDialog.hpp"
#include "ddt/dialogs/ddtDialogIds.hpp"
#include "qpushbutton.h"
 

class SamplesAccumulator {
public:
  SamplesAccumulator() : 
      m_accumulator(boost::accumulators::tag::rolling_window::window_size = 10), m_last() {
  };

  void Reset() {
    m_accumulator = boost::accumulators::accumulator_set<double, boost::accumulators::stats<boost::accumulators::tag::rolling_mean>>(
        boost::accumulators::tag::rolling_window::window_size = 10);
    m_last.reset();
  };

  std::optional<float> UpdateSamples(unsigned int counter, std::chrono::system_clock::time_point ts) {
    std::optional<float> res;
 
    if (m_last.has_value()) {
      if (m_last->first != counter) {
        using Duration = std::chrono::duration<double>;
        auto duration_sec = std::chrono::duration_cast<Duration>(ts - m_last->second);
        auto samples_per_sec = static_cast<double>(counter - m_last->first) / duration_sec.count();
 
        m_accumulator(samples_per_sec);
        m_last.emplace(counter, ts);
      }
 
      res = boost::accumulators::rolling_mean(m_accumulator);
    } else {
      m_last.emplace(counter, ts);
    }
 
    return res;
  };

  std::pair<float, char const*> ReadableByteSize(std::optional<float> num_bytes) {
    float ret = num_bytes.value_or(0.0);
    size_t num = 0;
 
    while (ret > 1024.0) {
      ret /= 1024.0;
      num++;
    }
 
    switch (num) {
    case 1:
      return {ret, " kib"};
    case 2:
      return {ret, " Mib"};
    case 3:
      return {ret, " Gib"};
    case 4:
      return {ret, " Tib"};
    case 5:
      return {ret, " Pib"};
    case 6:
      return {ret, " Eib"};
    case 0:
      [[fallthrough]];
    default:
      return {ret, " b"};
    }
  };
 
private:
  boost::accumulators::accumulator_set<double, boost::accumulators::stats<boost::accumulators::tag::rolling_mean>> m_accumulator;
  std::optional<std::pair<unsigned int, std::chrono::system_clock::time_point>> m_last;
};
 

class ddtMonitorSamplesDialog : public DdtDialog {
  Q_OBJECT
 
public:
  explicit ddtMonitorSamplesDialog(QWidget* parent = nullptr);

  virtual ~ddtMonitorSamplesDialog() = default;

  void SetInitialParameter(const QString parameter_id,
                           const QVariant parameter) override;

  void SetChangedParameter(const QString param_id,
                           const QVariant parameter) override;

  QString GetDialogName() override;
 
protected:
  virtual void CreateDialog() override;
 
  void closeEvent(QCloseEvent *event) override;
 
private:
  QLineEdit* linedit_queue_capacity;
  QLineEdit* linedit_originating_broker;
  QLineEdit* linedit_frequency;
  QLineEdit* linedit_throughput;
  QLineEdit* linedit_latency;
  QLineEdit* linedit_samples_count;
  QLineEdit* linedit_number_subscribers;
  QLineEdit* linedit_last_sample;
 
  QPushButton* pushbutton_toggle_on;
  QPushButton* pushbutton_toggle_off;
 
  SamplesAccumulator samples_stat;
  SamplesAccumulator bytes_stat;
  SamplesAccumulator latency_stat;
 
  bool monitor_on_off_flag;
 
  /*
  * Add connections ot respective widgets from current dialog
  */
  void ConnectWidgets();
};
 
#endif  // DDT_DATAVISUALISATION_DDTDIALOGS_MONITORSAMPLES_HPP