llvm-project/lldb/tools/lldb-perf/lib/Measurement.h

218 lines
5.6 KiB
C++

//===-- Measurement.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef __PerfTestDriver__Measurement__
#define __PerfTestDriver__Measurement__
#include "Gauge.h"
#include "Timer.h"
#include "Metric.h"
#include "MemoryGauge.h"
namespace lldb_perf
{
template <typename GaugeType, typename Callable>
class Measurement
{
public:
Measurement () :
m_gauge (),
m_callable (),
m_metric ()
{
}
Measurement (Callable callable, const char* name, const char* desc) :
m_gauge (),
m_callable (callable),
m_metric (Metric<typename GaugeType::ValueType>(name, desc))
{
}
Measurement (const char* name, const char* desc) :
m_gauge (),
m_callable (),
m_metric (Metric<typename GaugeType::ValueType>(name, desc))
{
}
template <typename GaugeType_Rhs, typename Callable_Rhs>
Measurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
m_gauge(rhs.GetGauge()),
m_callable(rhs.GetCallable()),
m_metric(rhs.GetMetric())
{
}
template <typename... Args>
void
operator () (Args... args)
{
m_gauge.Start();
m_callable(args...);
m_metric.Append (m_gauge.Stop());
}
virtual const Callable&
GetCallable () const
{
return m_callable;
}
virtual const GaugeType&
GetGauge () const
{
return m_gauge;
}
virtual const Metric<typename GaugeType::ValueType>&
GetMetric () const
{
return m_metric;
}
void
Start ()
{
m_gauge.Start();
}
typename GaugeType::ValueType
Stop ()
{
auto value = m_gauge.Stop();
m_metric.Append(value);
return value;
}
void
WriteStartValue (Results &results)
{
auto metric = GetMetric ();
results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStartValue()));
}
void
WriteStopValue (Results &results)
{
auto metric = GetMetric ();
results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStopValue()));
}
void
WriteAverageValue (Results &results)
{
auto metric = GetMetric ();
results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage()));
}
void
WriteAverageAndStandardDeviation (Results &results)
{
auto metric = GetMetric ();
auto dictionary = (Results::Dictionary*)results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage())).get();
if (dictionary)
{
dictionary->Add("stddev", NULL, lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
}
}
void
WriteStandardDeviation (Results &results)
{
auto metric = GetMetric ();
results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
}
protected:
GaugeType m_gauge;
Callable m_callable;
Metric<typename GaugeType::ValueType> m_metric;
};
template <typename Callable>
class TimeMeasurement : public Measurement<TimeGauge,Callable>
{
public:
TimeMeasurement () :
Measurement<TimeGauge,Callable> ()
{
}
TimeMeasurement (Callable callable,
const char* name = NULL,
const char* descr = NULL) :
Measurement<TimeGauge,Callable> (callable, name, descr)
{
}
template <typename Callable_Rhs>
TimeMeasurement (const TimeMeasurement<Callable_Rhs>& rhs) :
Measurement<TimeGauge,Callable>(rhs)
{
}
template <typename GaugeType_Rhs, typename Callable_Rhs>
TimeMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
{
}
template <typename... Args>
void
operator () (Args... args)
{
Measurement<TimeGauge,Callable>::operator()(args...);
}
};
template <typename Callable>
class MemoryMeasurement : public Measurement<MemoryGauge,Callable>
{
public:
MemoryMeasurement () : Measurement<MemoryGauge,Callable> ()
{
}
MemoryMeasurement (Callable callable,
const char* name,
const char* descr) :
Measurement<MemoryGauge,Callable> (callable, name, descr)
{
}
MemoryMeasurement (const char* name, const char* descr) :
Measurement<MemoryGauge,Callable> (name, descr)
{
}
template <typename Callable_Rhs>
MemoryMeasurement (const MemoryMeasurement<Callable_Rhs>& rhs) :
Measurement<MemoryGauge,Callable>(rhs)
{
}
template <typename GaugeType_Rhs, typename Callable_Rhs>
MemoryMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
{
}
template <typename... Args>
void
operator () (Args... args)
{
Measurement<MemoryGauge,Callable>::operator()(args...);
}
};
}
#endif /* defined(__PerfTestDriver__Measurement__) */