Measurement.h revision d2c50b1793f69af4d09b5ba364dc0a1a88ec26f5 
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
115protected:
116    GaugeType m_gauge;
117    Callable m_callable;
118    Metric<typename GaugeType::ValueType> m_metric;
119};
120
121template <typename Callable>
122class TimeMeasurement : public Measurement<TimeGauge,Callable>
123{
124public:
125    TimeMeasurement () :
126        Measurement<TimeGauge,Callable> ()
127    {
128    }
129
130    TimeMeasurement (Callable callable,
131                     const char* name = NULL,
132                     const char* descr = NULL) :
133        Measurement<TimeGauge,Callable> (callable, name, descr)
134    {
135    }
136
137    template <typename Callable_Rhs>
138    TimeMeasurement (const TimeMeasurement<Callable_Rhs>& rhs) :
139        Measurement<TimeGauge,Callable>(rhs)
140    {
141    }
142
143    template <typename GaugeType_Rhs, typename Callable_Rhs>
144    TimeMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
145        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
146    {
147    }
148
149    template <typename... Args>
150    void
151    operator () (Args... args)
152    {
153        Measurement<TimeGauge,Callable>::operator()(args...);
154    }
155};
156
157template <typename Callable>
158class MemoryMeasurement : public Measurement<MemoryGauge,Callable>
159{
160public:
161    MemoryMeasurement () : Measurement<MemoryGauge,Callable> ()
162    {
163    }
164
165    MemoryMeasurement (Callable callable,
166                       const char* name,
167                       const char* descr) :
168        Measurement<MemoryGauge,Callable> (callable, name, descr)
169    {
170    }
171
172    MemoryMeasurement (const char* name, const char* descr) :
173        Measurement<MemoryGauge,Callable> (name, descr)
174    {
175    }
176
177    template <typename Callable_Rhs>
178    MemoryMeasurement (const MemoryMeasurement<Callable_Rhs>& rhs) :
179        Measurement<MemoryGauge,Callable>(rhs)
180    {
181    }
182
183    template <typename GaugeType_Rhs, typename Callable_Rhs>
184    MemoryMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
185        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
186    {
187    }
188
189    template <typename... Args>
190    void
191    operator () (Args... args)
192    {
193        Measurement<MemoryGauge,Callable>::operator()(args...);
194    }
195};
196
197}
198
199#endif /* defined(__PerfTestDriver__Measurement__) */
200