1 files changed, 122 insertions, 181 deletions
diff --git a/lldb/tools/lldb-perf/lib/Measurement.h b/lldb/tools/lldb-perf/lib/Measurement.h
index 877e618..1795211 100644
--- a/lldb/tools/lldb-perf/lib/Measurement.h
+++ b/lldb/tools/lldb-perf/lib/Measurement.h
@@ -11,207 +11,148 @@
 #define __PerfTestDriver__Measurement__
 
 #include "Gauge.h"
-#include "Timer.h"
-#include "Metric.h"
 #include "MemoryGauge.h"
+#include "Metric.h"
+#include "Timer.h"
 
-namespace lldb_perf
-{
-template <typename GaugeType, typename Callable>
-class Measurement
-{
+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() : m_gauge(), m_callable(), m_metric() {}
 
-    Measurement (const char* name, const char* desc)  :
-        m_gauge (),
-        m_callable (),
-        m_metric (Metric<typename GaugeType::ValueType>(name, desc))
-    {
-    }
+  Measurement(Callable callable, const char *name, const char *desc)
+      : m_gauge(), m_callable(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())
-    {
-    }
+  Measurement(const char *name, const char *desc)
+      : m_gauge(), m_callable(),
+        m_metric(Metric<typename GaugeType::ValueType>(name, desc)) {}
 
-    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;
-    }
+  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()) {}
 
-    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()));
-    }
+  template <typename... Args> void operator()(Args... args) {
+    m_gauge.Start();
+    m_callable(args...);
+    m_metric.Append(m_gauge.Stop());
+  }
 
-    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()));
-    }
+  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;
+  GaugeType m_gauge;
+  Callable m_callable;
+  Metric<typename GaugeType::ValueType> m_metric;
 };
-    
+
 template <typename Callable>
-class TimeMeasurement : public Measurement<TimeGauge,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...);
-    }
+  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>
-{
+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() : Measurement<MemoryGauge, Callable>() {}
 
-    MemoryMeasurement (const char* name, const char* descr) :
-        Measurement<MemoryGauge,Callable> (name, descr)
-    {
-    }
+  MemoryMeasurement(Callable callable, const char *name, const char *descr)
+      : Measurement<MemoryGauge, Callable>(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...);
-    }
+  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__) */