benchmark.h

Go to the documentation of this file.

#ifndef ION_ANALYTICS_BENCHMARK_H_
#define ION_ANALYTICS_BENCHMARK_H_

#include <string>
#include <vector>

#include "base/integral_types.h"
#include "ion/port/timer.h"

namespace ion {
namespace analytics {

class ION_API Benchmark {
 public:
  struct Descriptor {
    Descriptor(const std::string& id_in,
               const std::string& group_in,
               const std::string& description_in,
               const std::string& units_in)
        : id(id_in),
          group(group_in),
          description(description_in),
          units(units_in) {}
    std::string id;            // (Unique) identifying name.
    std::string group;         // Group the measurement belongs to.
    std::string description;   // Readable description.
    std::string units;         // Description of units.
  };

  struct Constant {
    Constant(const Descriptor& descriptor_in, double value_in)
        : descriptor(descriptor_in),
          value(value_in) {}
    Descriptor descriptor;
    double value;
  };

  struct Sample {
    Sample(uint32 time_offset_ms_in, double value_in)
        : time_offset_ms(time_offset_ms_in),
          value(value_in) {}
    uint32 time_offset_ms;
    double value;
  };

  struct SampledVariable {
    explicit SampledVariable(const Descriptor& descriptor_in)
        : descriptor(descriptor_in) {}
    Descriptor descriptor;
    std::vector<Sample> samples;
  };

  struct AccumulatedVariable {
    AccumulatedVariable(const Descriptor& descriptor_in, size_t samples_in,
                        double minimum_in, double maximum_in,
                        double mean_in, double standard_deviation_in)
        : descriptor(descriptor_in),
          samples(samples_in),
          minimum(minimum_in),
          maximum(maximum_in),
          mean(mean_in),
          standard_deviation(standard_deviation_in) {}
    Descriptor descriptor;
    size_t samples;             // Number of samples taken.
    double minimum;             // Minimum value.
    double maximum;             // Maximum value.
    double mean;                // Average (mean) value.
    double standard_deviation;  // Standard deviation of value.
  };

  class ION_API VariableSampler {
   public:
    explicit VariableSampler(const Descriptor& descriptor)
        : variable_(descriptor) {}

    void AddSample(double value);

    const SampledVariable Get() { return variable_; }

   private:
    SampledVariable variable_;

    ion::port::Timer timer_;
  };

  class ION_API VariableAccumulator {
   public:
    explicit VariableAccumulator(const Descriptor& descriptor);

    void AddSample(double value);

    const AccumulatedVariable Get();

   private:
    AccumulatedVariable variable_;
    double m2_;  // Needed by Welford's algorithm.
  };

  void AddConstant(const Constant& constant) { constants_.push_back(constant); }
  void AddSampledVariable(const SampledVariable& variable) {
    sampled_variables_.push_back(variable);
  }
  void AddAccumulatedVariable(const AccumulatedVariable& variable) {
    accumulated_variables_.push_back(variable);
  }

  const std::vector<Constant>& GetConstants() const { return constants_; }
  const std::vector<SampledVariable>& GetSampledVariables() const {
    return sampled_variables_;
  }
  const std::vector<AccumulatedVariable>& GetAccumulatedVariables() const {
    return accumulated_variables_;
  }

  static const AccumulatedVariable AccumulateSampledVariable(
      const SampledVariable& sampled_variable);

 private:
  std::vector<Constant> constants_;
  std::vector<SampledVariable> sampled_variables_;
  std::vector<AccumulatedVariable> accumulated_variables_;
};

}  // namespace analytics
}  // namespace ion

#endif  // ION_ANALYTICS_BENCHMARK_H_