1 files changed, 217 insertions, 0 deletions
diff --git a/tools/lldb-perf/lib/Measurement.h b/tools/lldb-perf/lib/Measurement.h
new file mode 100644
index 000000000000..877e618d5469
--- /dev/null
+++ b/tools/lldb-perf/lib/Measurement.h
@@ -0,0 +1,217 @@
+//===-- 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__) */