phase_metrics.h

Go to the documentation of this file.

 
#ifndef CPPBENCHMARK_PHASE_METRICS_H
#define CPPBENCHMARK_PHASE_METRICS_H
 
#include <cstdint>
#include <limits>
#include <map>
#include <string>
 
namespace CppBenchmark {
 
 
class PhaseMetrics
{
    friend class PhaseCore;
 
public:
    PhaseMetrics();
    PhaseMetrics(const PhaseMetrics&) = default;
    PhaseMetrics(PhaseMetrics&&) noexcept = default;
    ~PhaseMetrics();
 
    PhaseMetrics& operator=(const PhaseMetrics&) = default;
    PhaseMetrics& operator=(PhaseMetrics&&) noexcept = default;
 
    bool latency() const noexcept;
    int64_t min_latency() const noexcept;
    int64_t max_latency() const noexcept;
    double mean_latency() const noexcept;
    double stdv_latency() const noexcept;
 
    int64_t avg_time() const noexcept;
    int64_t min_time() const noexcept;
    int64_t max_time() const noexcept;
 
    int64_t total_time() const noexcept { return _total_time; }
    int64_t total_operations() const noexcept { return _total_operations; }
    int64_t total_items() const noexcept { return _total_items; }
    int64_t total_bytes() const noexcept { return _total_bytes; }
 
    int64_t operations_per_second() const noexcept;
    int64_t items_per_second() const noexcept;
    int64_t bytes_per_second() const noexcept;
 
    const std::map<std::string, int>& custom_int() const noexcept { return _custom_int; }
    const std::map<std::string, unsigned>& custom_uint() const noexcept { return _custom_uint; }
    const std::map<std::string, int64_t>& custom_int64() const noexcept { return _custom_int64; }
    const std::map<std::string, uint64_t>& custom_uint64() const noexcept { return _custom_uint64; }
    const std::map<std::string, float>& custom_flt() const noexcept { return _custom_flt; }
    const std::map<std::string, double>& custom_dbl() const noexcept { return _custom_dbl; }
    const std::map<std::string, std::string>& custom_str() const noexcept { return _custom_str; }
 
    int threads() const noexcept { return _threads; }
 
 
    void AddOperations(int64_t operations) noexcept
    { _total_operations += operations; }
 
    void AddItems(int64_t items) noexcept
    { _total_items += items; }
 
    void AddBytes(int64_t bytes) noexcept
    { _total_bytes += bytes; }
 
 
    void SetCustom(const std::string& name, int value)
    { _custom_int[name] = value; }
 
    void SetCustom(const std::string& name, unsigned value)
    { _custom_uint[name] = value; }
 
    void SetCustom(const std::string& name, int64_t value)
    { _custom_int64[name] = value; }
 
    void SetCustom(const std::string& name, uint64_t value)
    { _custom_uint64[name] = value; }
 
    void SetCustom(const std::string& name, float value)
    { _custom_flt[name] = value; }
 
    void SetCustom(const std::string& name, double value)
    { _custom_dbl[name] = value; }
 
    void SetCustom(const std::string& name, const std::string& value)
    { _custom_str[name].assign(value); }
 
 
    void SetThreads(int threads)
    { _threads = threads; }
 
 
    void AddLatency(int64_t latency) noexcept;
 
private:
    void* _histogram;
    int64_t _min_time;
    int64_t _max_time;
    int64_t _total_time;
    int64_t _total_operations;
    int64_t _total_items;
    int64_t _total_bytes;
    std::map<std::string, int> _custom_int;
    std::map<std::string, unsigned> _custom_uint;
    std::map<std::string, int64_t> _custom_int64;
    std::map<std::string, uint64_t> _custom_uint64;
    std::map<std::string, float> _custom_flt;
    std::map<std::string, double> _custom_dbl;
    std::map<std::string, std::string> _custom_str;
 
    int64_t _iterstamp;
    int64_t _timestamp;
 
    int _threads;
 
    void InitLatencyHistogram(const std::tuple<int64_t, int64_t, int>& latency) noexcept;
    void PrintLatencyHistogram(FILE* file, int32_t resolution) const noexcept;
    void FreeLatencyHistogram() noexcept;
 
    void StartCollecting() noexcept;
    void StopCollecting() noexcept;
 
    void MergeMetrics(PhaseMetrics& metrics);
    void ResetMetrics() noexcept;
};
 
} // namespace CppBenchmark
 
#endif // CPPBENCHMARK_PHASE_METRICS_H