Measurement.h revision 08257e457b2aab6453618cb64c033e5a64115da1
1//===-- Measurement.h -------------------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef __PerfTestDriver__Measurement__ 11#define __PerfTestDriver__Measurement__ 12 13#include "Gauge.h" 14#include "Timer.h" 15#include "Metric.h" 16#include "MemoryGauge.h" 17 18namespace lldb_perf 19{ 20template <typename GaugeType, typename Callable> 21class Measurement 22{ 23public: 24 Measurement () : 25 m_gauge (), 26 m_callable (), 27 m_metric () 28 { 29 } 30 31 Measurement (Callable callable, const char* name, const char* desc) : 32 m_gauge (), 33 m_callable (callable), 34 m_metric (Metric<typename GaugeType::ValueType>(name, desc)) 35 { 36 } 37 38 Measurement (const char* name, const char* desc) : 39 m_gauge (), 40 m_callable (), 41 m_metric (Metric<typename GaugeType::ValueType>(name, desc)) 42 { 43 } 44 45 template <typename GaugeType_Rhs, typename Callable_Rhs> 46 Measurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) : 47 m_gauge(rhs.GetGauge()), 48 m_callable(rhs.GetCallable()), 49 m_metric(rhs.GetMetric()) 50 { 51 } 52 53 template <typename... Args> 54 void 55 operator () (Args... args) 56 { 57 m_gauge.Start(); 58 m_callable(args...); 59 m_metric.Append (m_gauge.Stop()); 60 } 61 62 virtual const Callable& 63 GetCallable () const 64 { 65 return m_callable; 66 } 67 68 virtual const GaugeType& 69 GetGauge () const 70 { 71 return m_gauge; 72 } 73 74 virtual const Metric<typename GaugeType::ValueType>& 75 GetMetric () const 76 { 77 return m_metric; 78 } 79 80 void 81 Start () 82 { 83 m_gauge.Start(); 84 } 85 86 typename GaugeType::ValueType 87 Stop () 88 { 89 auto value = m_gauge.Stop(); 90 m_metric.Append(value); 91 return value; 92 } 93 94 void 95 WriteStartValue (Results &results) 96 { 97 auto metric = GetMetric (); 98 results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStartValue())); 99 } 100 101 void 102 WriteStopValue (Results &results) 103 { 104 auto metric = GetMetric (); 105 results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStopValue())); 106 } 107 108 void 109 WriteAverageValue (Results &results) 110 { 111 auto metric = GetMetric (); 112 results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage())); 113 } 114 115 void 116 WriteStandardDeviation (Results &results) 117 { 118 auto metric = GetMetric (); 119 results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation())); 120 } 121 122protected: 123 GaugeType m_gauge; 124 Callable m_callable; 125 Metric<typename GaugeType::ValueType> m_metric; 126}; 127 128template <typename Callable> 129class TimeMeasurement : public Measurement<TimeGauge,Callable> 130{ 131public: 132 TimeMeasurement () : 133 Measurement<TimeGauge,Callable> () 134 { 135 } 136 137 TimeMeasurement (Callable callable, 138 const char* name = NULL, 139 const char* descr = NULL) : 140 Measurement<TimeGauge,Callable> (callable, name, descr) 141 { 142 } 143 144 template <typename Callable_Rhs> 145 TimeMeasurement (const TimeMeasurement<Callable_Rhs>& rhs) : 146 Measurement<TimeGauge,Callable>(rhs) 147 { 148 } 149 150 template <typename GaugeType_Rhs, typename Callable_Rhs> 151 TimeMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) : 152 Measurement<GaugeType_Rhs,Callable_Rhs>(rhs) 153 { 154 } 155 156 template <typename... Args> 157 void 158 operator () (Args... args) 159 { 160 Measurement<TimeGauge,Callable>::operator()(args...); 161 } 162}; 163 164template <typename Callable> 165class MemoryMeasurement : public Measurement<MemoryGauge,Callable> 166{ 167public: 168 MemoryMeasurement () : Measurement<MemoryGauge,Callable> () 169 { 170 } 171 172 MemoryMeasurement (Callable callable, 173 const char* name, 174 const char* descr) : 175 Measurement<MemoryGauge,Callable> (callable, name, descr) 176 { 177 } 178 179 MemoryMeasurement (const char* name, const char* descr) : 180 Measurement<MemoryGauge,Callable> (name, descr) 181 { 182 } 183 184 template <typename Callable_Rhs> 185 MemoryMeasurement (const MemoryMeasurement<Callable_Rhs>& rhs) : 186 Measurement<MemoryGauge,Callable>(rhs) 187 { 188 } 189 190 template <typename GaugeType_Rhs, typename Callable_Rhs> 191 MemoryMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) : 192 Measurement<GaugeType_Rhs,Callable_Rhs>(rhs) 193 { 194 } 195 196 template <typename... Args> 197 void 198 operator () (Args... args) 199 { 200 Measurement<MemoryGauge,Callable>::operator()(args...); 201 } 202}; 203 204} 205 206#endif /* defined(__PerfTestDriver__Measurement__) */ 207