Measurement.h revision d3a8d6565ff40fd99533f50a085ace806a9300ee 
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 Action>
21class Measurement : public WriteToPList
22{
23public:
24    Measurement () :
25        m_gauge (),
26        m_action (),
27        m_metric ()
28    {
29    }
30
31    Measurement (Action act, const char* name = NULL, const char* desc = NULL)  :
32        m_gauge (),
33        m_action (act),
34        m_metric (Metric<typename GaugeType::SizeType>(name, desc))
35    {
36    }
37
38    template <typename GaugeType_Rhs, typename Action_Rhs>
39    Measurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) :
40        m_gauge(rhs.GetGauge()),
41        m_action(rhs.GetAction()),
42        m_metric(rhs.GetMetric())
43    {
44    }
45
46    template <typename... Args>
47    void
48    operator () (Args... args)
49    {
50        m_metric.Append (m_gauge.Measure(m_action, args...));
51    }
52
53    virtual const Action&
54    GetAction () const
55    {
56        return m_action;
57    }
58
59    virtual const GaugeType&
60    GetGauge () const
61    {
62        return m_gauge;
63    }
64
65    virtual const Metric<typename GaugeType::SizeType>&
66    GetMetric () const
67    {
68        return m_metric;
69    }
70
71    void
72    Start ()
73    {
74        m_gauge.Start();
75    }
76
77    typename GaugeType::SizeType
78    Stop ()
79    {
80        auto value = m_gauge.Stop();
81        m_metric.Append(value);
82        return value;
83    }
84
85    virtual void
86    Write (CFCMutableArray& parent)
87    {
88        m_metric.Write(parent);
89    }
90
91protected:
92    GaugeType m_gauge;
93    Action m_action;
94    Metric<typename GaugeType::SizeType> m_metric;
95};
96
97template <typename Action>
98class TimeMeasurement : public Measurement<TimeGauge,Action>
99{
100public:
101    TimeMeasurement () :
102        Measurement<TimeGauge,Action> ()
103    {
104    }
105
106    TimeMeasurement (Action act,
107                     const char* name = NULL,
108                     const char* descr = NULL) :
109        Measurement<TimeGauge,Action> (act, name, descr)
110    {
111    }
112
113    template <typename Action_Rhs>
114    TimeMeasurement (const TimeMeasurement<Action_Rhs>& rhs) :
115        Measurement<TimeGauge,Action>(rhs)
116    {
117    }
118
119    template <typename GaugeType_Rhs, typename Action_Rhs>
120    TimeMeasurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) :
121        Measurement<GaugeType_Rhs,Action_Rhs>(rhs)
122    {
123    }
124
125    template <typename... Args>
126    void
127    operator () (Args... args)
128    {
129        Measurement<TimeGauge,Action>::operator()(args...);
130    }
131};
132
133template <typename Action>
134class MemoryMeasurement : public Measurement<MemoryGauge,Action>
135{
136public:
137    MemoryMeasurement () : Measurement<MemoryGauge,Action> ()
138    {
139    }
140
141    MemoryMeasurement (Action act, const char* name = NULL, const char* descr = NULL) : Measurement<MemoryGauge,Action> (act, name, descr)
142    {
143    }
144
145    template <typename Action_Rhs>
146    MemoryMeasurement (const MemoryMeasurement<Action_Rhs>& rhs) : Measurement<MemoryGauge,Action>(rhs)
147    {
148    }
149
150    template <typename GaugeType_Rhs, typename Action_Rhs>
151    MemoryMeasurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) : Measurement<GaugeType_Rhs,Action_Rhs>(rhs)
152    {
153    }
154
155    template <typename... Args>
156    void
157    operator () (Args... args)
158    {
159        Measurement<MemoryGauge,Action>::operator()(args...);
160    }
161};
162
163}
164
165#endif /* defined(__PerfTestDriver__Measurement__) */
166