Modify code to adhere to LLDB coding conventions.

llvm-svn: 177623

10 files changed, 192 insertions, 166 deletions

diff --git a/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp b/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
index 1d516852e24..846bdb7e821 100644
--- a/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
+++ b/lldb/tools/lldb-perf/darwin/formatters/formatters.cpp
@@ -119,25 +119,25 @@ public:
         auto sstr3 = frame_zero.FindVariable("sstr3", lldb::eDynamicCanRunTarget);
         auto sstr4 = frame_zero.FindVariable("sstr4", lldb::eDynamicCanRunTarget);
         
-        m_dump_std_string_measurement.start();
+        m_dump_std_string_measurement.Start();
         Xcode::FetchVariable(sstr0,0,false);
-        m_dump_std_string_measurement.stop();
+        m_dump_std_string_measurement.Stop();
         
-        m_dump_std_string_measurement.start();
+        m_dump_std_string_measurement.Start();
         Xcode::FetchVariable(sstr1,0,false);
-        m_dump_std_string_measurement.stop();
+        m_dump_std_string_measurement.Stop();
 
-        m_dump_std_string_measurement.start();
+        m_dump_std_string_measurement.Start();
         Xcode::FetchVariable(sstr2,0,false);
-        m_dump_std_string_measurement.stop();
+        m_dump_std_string_measurement.Stop();
 
-        m_dump_std_string_measurement.start();
+        m_dump_std_string_measurement.Start();
         Xcode::FetchVariable(sstr3,0,false);
-        m_dump_std_string_measurement.stop();
+        m_dump_std_string_measurement.Stop();
 
-        m_dump_std_string_measurement.start();
+        m_dump_std_string_measurement.Start();
         Xcode::FetchVariable(sstr4,0,false);
-        m_dump_std_string_measurement.stop();
+        m_dump_std_string_measurement.Stop();
         
     }
     
diff --git a/lldb/tools/lldb-perf/lib/Gauge.h b/lldb/tools/lldb-perf/lib/Gauge.h
index 33e6a284af3..1a38f070678 100644
--- a/lldb/tools/lldb-perf/lib/Gauge.h
+++ b/lldb/tools/lldb-perf/lib/Gauge.h
@@ -11,8 +11,8 @@
 
 #include <functional>
 
-namespace lldb_perf
-{
+namespace lldb_perf {
+
 template <class TASizeType>
 class Gauge
 {
@@ -27,21 +27,21 @@ public:
     {}
     
     virtual void
-    start () = 0;
+    Start () = 0;
     
     virtual SizeType
-    stop () = 0;
+    Stop () = 0;
     
     virtual  SizeType
-    value () = 0;
+    GetValue () = 0;
     
     template <typename F, typename... Args>
     SizeType
-    gauge (F f,Args... args)
+    Measure (F f,Args... args)
     {
-        start();
+        Start();
         f(args...);
-        return stop();
+        return Stop();
     }
 
 };
diff --git a/lldb/tools/lldb-perf/lib/Measurement.h b/lldb/tools/lldb-perf/lib/Measurement.h
index 798499bf52d..120cd18eb6f 100644
--- a/lldb/tools/lldb-perf/lib/Measurement.h
+++ b/lldb/tools/lldb-perf/lib/Measurement.h
@@ -20,19 +20,25 @@ template <typename GaugeType, typename Action>
 class Measurement : public WriteToPList
 {
 public:
-    Measurement () {}
+    Measurement () :
+        m_gauge (),
+        m_action (),
+        m_metric ()
+    {
+    }
     
-    Measurement (Action act, const char* name = NULL, const char* descr = NULL)  :
-    m_gauge (),
-    m_action (act),
-    m_metric (Metric<typename GaugeType::SizeType>(name,descr))
-    {}
+    Measurement (Action act, const char* name = NULL, const char* desc = NULL)  :
+        m_gauge (),
+        m_action (act),
+        m_metric (Metric<typename GaugeType::SizeType>(name, desc))
+    {
+    }
     
     template <typename GaugeType_Rhs, typename Action_Rhs>
     Measurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) :
-    m_gauge(rhs.gauge()),
-    m_action(rhs.action()),
-    m_metric(rhs.metric())
+        m_gauge(rhs.GetGauge()),
+        m_action(rhs.GetAction()),
+        m_metric(rhs.GetMetric())
     {
     }
 
@@ -40,41 +46,41 @@ public:
     void
     operator () (Args... args)
     {
-        m_metric.append (m_gauge.gauge(m_action,args...));
+        m_metric.Append (m_gauge.Measure(m_action, args...));
     }
     
-    virtual const Metric<typename GaugeType::SizeType>&
-    metric () const
+    virtual const Action&
+    GetAction () const
     {
-        return m_metric;
+        return m_action;
     }
     
-    void
-    start ()
+    virtual const GaugeType&
+    GetGauge () const
     {
-        m_gauge.start();
+        return m_gauge;
     }
     
-    typename GaugeType::SizeType
-    stop ()
+    virtual const Metric<typename GaugeType::SizeType>&
+    GetMetric () const
     {
-        auto value = m_gauge.stop();
-        m_metric.append(value);
-        return value;
+        return m_metric;
     }
     
-    virtual const GaugeType&
-    gauge () const
+    void
+    Start ()
     {
-        return m_gauge;
+        m_gauge.Start();
     }
     
-    virtual const Action&
-    action () const
+    typename GaugeType::SizeType
+    Stop ()
     {
-        return m_action;
+        auto value = m_gauge.Stop();
+        m_metric.Append(value);
+        return value;
     }
-    
+        
     virtual void
     Write (CFCMutableArray& parent)
     {
@@ -91,19 +97,29 @@ template <typename Action>
 class TimeMeasurement : public Measurement<TimeGauge,Action>
 {
 public:
-    TimeMeasurement () : Measurement<TimeGauge,Action> ()
-    {}
+    TimeMeasurement () :
+        Measurement<TimeGauge,Action> ()
+    {
+    }
     
-    TimeMeasurement (Action act, const char* name = NULL, const char* descr = NULL) : Measurement<TimeGauge,Action> (act, name, descr)
-    {}
+    TimeMeasurement (Action act,
+                     const char* name = NULL,
+                     const char* descr = NULL) :
+        Measurement<TimeGauge,Action> (act, name, descr)
+    {
+    }
     
     template <typename Action_Rhs>
-    TimeMeasurement (const TimeMeasurement<Action_Rhs>& rhs) : Measurement<TimeGauge,Action>(rhs)
-    {}
+    TimeMeasurement (const TimeMeasurement<Action_Rhs>& rhs) :
+        Measurement<TimeGauge,Action>(rhs)
+    {
+    }
     
     template <typename GaugeType_Rhs, typename Action_Rhs>
-    TimeMeasurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) : Measurement<GaugeType_Rhs,Action_Rhs>(rhs)
-    {}
+    TimeMeasurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) :
+        Measurement<GaugeType_Rhs,Action_Rhs>(rhs)
+    {
+    }
     
     template <typename... Args>
     void
@@ -118,18 +134,22 @@ class MemoryMeasurement : public Measurement<MemoryGauge,Action>
 {
 public:
     MemoryMeasurement () : Measurement<MemoryGauge,Action> ()
-    {}
+    {
+    }
     
     MemoryMeasurement (Action act, const char* name = NULL, const char* descr = NULL) : Measurement<MemoryGauge,Action> (act, name, descr)
-    {}
+    {
+    }
     
     template <typename Action_Rhs>
     MemoryMeasurement (const MemoryMeasurement<Action_Rhs>& rhs) : Measurement<MemoryGauge,Action>(rhs)
-    {}
+    {
+    }
     
     template <typename GaugeType_Rhs, typename Action_Rhs>
     MemoryMeasurement (const Measurement<GaugeType_Rhs, Action_Rhs>& rhs) : Measurement<GaugeType_Rhs,Action_Rhs>(rhs)
-    {}
+    {
+    }
     
     template <typename... Args>
     void
diff --git a/lldb/tools/lldb-perf/lib/MemoryGauge.cpp b/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
index 2a6faf2b2ab..969910408c2 100644
--- a/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
+++ b/lldb/tools/lldb-perf/lib/MemoryGauge.cpp
@@ -14,20 +14,27 @@
 
 using namespace lldb_perf;
 
-MemoryStats::MemoryStats () : MemoryStats(0,0,0) {}
-MemoryStats::MemoryStats (mach_vm_size_t vs,mach_vm_size_t rs, mach_vm_size_t mrs) :
-m_virtual_size(vs),
-m_resident_size(rs),
-m_max_resident_size(mrs)
-{}
+MemoryStats::MemoryStats (mach_vm_size_t virtual_size,
+                          mach_vm_size_t resident_size,
+                          mach_vm_size_t max_resident_size) :
+    m_virtual_size (virtual_size),
+    m_resident_size (resident_size),
+    m_max_resident_size (max_resident_size)
+{
+}
+
+MemoryStats::MemoryStats (const MemoryStats& rhs) :
+    m_virtual_size (rhs.m_virtual_size),
+    m_resident_size (rhs.m_resident_size),
+    m_max_resident_size (rhs.m_max_resident_size)
+{
+}
 
-MemoryStats::MemoryStats (const MemoryStats& rhs) : MemoryStats(rhs.m_virtual_size,rhs.m_resident_size,rhs.m_max_resident_size)
-{}
 
 MemoryStats&
 MemoryStats::operator = (const MemoryStats& rhs)
 {
-    if (&rhs != this)
+    if (this != &rhs)
     {
         m_virtual_size = rhs.m_virtual_size;
         m_resident_size = rhs.m_resident_size;
@@ -54,16 +61,16 @@ MemoryStats::operator - (const MemoryStats& rhs)
 }
 
 MemoryStats&
-MemoryStats::operator / (size_t rhs)
+MemoryStats::operator / (size_t n)
 {
-    m_virtual_size /= rhs;
-    m_resident_size /= rhs;
-    m_max_resident_size /= rhs;
+    m_virtual_size /= n;
+    m_resident_size /= n;
+    m_max_resident_size /= n;
     return *this;
 }
 
 MemoryGauge::SizeType
-MemoryGauge::now ()
+MemoryGauge::Now ()
 {
     task_t task = mach_task_self();
     mach_task_basic_info_data_t taskBasicInfo;
@@ -76,30 +83,30 @@ MemoryGauge::now ()
 }
 
 MemoryGauge::MemoryGauge () :
-m_start(),
-m_state(MemoryGauge::State::eMSNeverUsed)
+    m_start(),
+    m_state(MemoryGauge::State::eNeverUsed)
 {
 }
 
 void
-MemoryGauge::start ()
+MemoryGauge::Start ()
 {
-	m_state = MemoryGauge::State::eMSCounting;
-	m_start = now();
+	m_state = MemoryGauge::State::eCounting;
+	m_start = Now();
 }
 
 MemoryGauge::SizeType
-MemoryGauge::stop ()
+MemoryGauge::Stop ()
 {
-	auto stop = now();
-	assert(m_state == MemoryGauge::State::eMSCounting && "cannot stop a non-started gauge");
-	m_state = MemoryGauge::State::eMSStopped;
+	auto stop = Now();
+	assert(m_state == MemoryGauge::State::eCounting && "cannot stop a non-started gauge");
+	m_state = MemoryGauge::State::eStopped;
 	return (m_value = stop-m_start);
 }
 
 MemoryGauge::SizeType
-MemoryGauge::value ()
+MemoryGauge::GetValue ()
 {
-	assert(m_state == MemoryGauge::State::eMSStopped && "gauge must be used before you can evaluate it");
+	assert(m_state == MemoryGauge::State::eStopped && "gauge must be used before you can evaluate it");
 	return m_value;
 }
diff --git a/lldb/tools/lldb-perf/lib/MemoryGauge.h b/lldb/tools/lldb-perf/lib/MemoryGauge.h
index 821245557ed..7b357dc718b 100644
--- a/lldb/tools/lldb-perf/lib/MemoryGauge.h
+++ b/lldb/tools/lldb-perf/lib/MemoryGauge.h
@@ -18,8 +18,9 @@ namespace lldb_perf
 class MemoryStats
 {
 public:
-    MemoryStats ();
-    MemoryStats (mach_vm_size_t,mach_vm_size_t = 0, mach_vm_size_t = 0);
+    MemoryStats (mach_vm_size_t virtual_size = 0,
+                 mach_vm_size_t resident_size = 0,
+                 mach_vm_size_t max_resident_size = 0);
     MemoryStats (const MemoryStats& rhs);
     
     MemoryStats&
@@ -78,36 +79,38 @@ private:
 
 class MemoryGauge : public Gauge<MemoryStats>
 {
-private:
-    enum class State
-    {
-        eMSNeverUsed,
-        eMSCounting,
-        eMSStopped
-    };
-    
-    SizeType
-    now ();
-    
-    SizeType m_start;
-    State m_state;
-    SizeType m_value;
-
 public:
     MemoryGauge ();
     
     virtual
     ~MemoryGauge ()
-    {}
+    {
+    }
     
     void
-    start ();
+    Start ();
     
     SizeType
-    stop ();
+    Stop ();
     
     SizeType
-    value ();
+    GetValue ();
+
+private:
+    enum class State
+    {
+        eNeverUsed,
+        eCounting,
+        eStopped
+    };
+    
+    SizeType
+    Now ();
+    
+    SizeType m_start;
+    State m_state;
+    SizeType m_value;
+    
 };
 }
 
diff --git a/lldb/tools/lldb-perf/lib/Metric.cpp b/lldb/tools/lldb-perf/lib/Metric.cpp
index afacc9b11a4..df8a243b1cc 100644
--- a/lldb/tools/lldb-perf/lib/Metric.cpp
+++ b/lldb/tools/lldb-perf/lib/Metric.cpp
@@ -28,21 +28,21 @@ m_dataset ()
 
 template <class T>
 void
-Metric<T>::append (T v)
+Metric<T>::Append (T v)
 {
     m_dataset.push_back(v);
 }
 
 template <class T>
 size_t
-Metric<T>::count ()
+Metric<T>::GetCount () const
 {
     return m_dataset.size();
 }
 
 template <class T>
 T
-Metric<T>::sum ()
+Metric<T>::GetSum () const
 {
     T sum = 0;
     for (auto v : m_dataset)
@@ -52,32 +52,18 @@ Metric<T>::sum ()
 
 template <class T>
 T
-Metric<T>::average ()
+Metric<T>::GetAverage () const
 {
-    return sum()/count();
-}
-
-template <class T>
-const char*
-Metric<T>::name ()
-{
-    return m_name.c_str();
-}
-
-template <class T>
-const char*
-Metric<T>::description ()
-{
-    return m_description.c_str();
+    return GetSum()/GetCount();
 }
 
 template <>
 void Metric<double>::WriteImpl (CFCMutableArray& parent, identity<double>)
 {
     CFCMutableDictionary dict;
-    dict.AddValueCString(CFCString("name").get(),name(), true);
-    dict.AddValueCString(CFCString("description").get(),description(), true);
-    dict.AddValueDouble(CFCString("value").get(),this->average(), true);
+    dict.AddValueCString(CFCString("name").get(), GetName(), true);
+    dict.AddValueCString(CFCString("description").get(),GetDescription(), true);
+    dict.AddValueDouble(CFCString("value").get(),this->GetAverage(), true);
     parent.AppendValue(dict.get(), true);
 }
 
@@ -85,17 +71,17 @@ template <>
 void Metric<MemoryStats>::WriteImpl (CFCMutableArray& parent, identity<MemoryStats>)
 {
     CFCMutableDictionary dict;
-    dict.AddValueCString(CFCString("name").get(),name(), true);
-    dict.AddValueCString(CFCString("description").get(),description(), true);
+    dict.AddValueCString(CFCString("name").get(), GetName(), true);
+    dict.AddValueCString(CFCString("description").get(), GetDescription(), true);
     CFCMutableDictionary value;
 
-    auto avg = this->average();
+    auto avg = this->GetAverage();
     
     value.AddValueUInt64(CFCString("virtual").get(), avg.GetVirtualSize(), true);
     value.AddValueUInt64(CFCString("resident").get(), avg.GetResidentSize(), true);
     value.AddValueUInt64(CFCString("max_resident").get(), avg.GetMaxResidentSize(), true);
     
-    dict.AddValue(CFCString("value").get(),value.get(), true);
+    dict.AddValue(CFCString("value").get(), value.get(), true);
     
     parent.AppendValue(dict.get(), true);
 }
diff --git a/lldb/tools/lldb-perf/lib/Metric.h b/lldb/tools/lldb-perf/lib/Metric.h
index 981836c93d8..a3066c9c235 100644
--- a/lldb/tools/lldb-perf/lib/Metric.h
+++ b/lldb/tools/lldb-perf/lib/Metric.h
@@ -15,9 +15,10 @@
 
 #include "CFCMutableArray.h"
 
-namespace lldb_perf
-{
+namespace lldb_perf {
+
 class MemoryStats;
+
 class WriteToPList
 {
 public:
@@ -29,28 +30,35 @@ public:
 };
 
 template <class ValueType>
-class Metric : public WriteToPList {
+class Metric : public WriteToPList
+{
 public:
     Metric ();
     Metric (const char*, const char* = NULL);
     
     void
-    append (ValueType v);
-    
-    size_t
-    count ();
+    Append (ValueType v);
     
     ValueType
-    sum ();
+    GetAverage () const;
+    
+    size_t
+    GetCount () const;
     
     ValueType
-    average ();
+    GetSum () const;
     
     const char*
-    name ();
-    
+    GetName ()
+    {
+        return m_name.c_str();
+    }
+
     const char*
-    description ();
+    GetDescription ()
+    {
+        return m_description.c_str();
+    }
     
     virtual void
     Write (CFCMutableArray& parent)
diff --git a/lldb/tools/lldb-perf/lib/TestCase.h b/lldb/tools/lldb-perf/lib/TestCase.h
index 2cfdec9c0eb..707806bf157 100644
--- a/lldb/tools/lldb-perf/lib/TestCase.h
+++ b/lldb/tools/lldb-perf/lib/TestCase.h
@@ -67,7 +67,8 @@ public:
     
     virtual
     ~TestCase ()
-    {}
+    {
+    }
     
 	virtual bool
 	Setup (int argc, const char** argv);
diff --git a/lldb/tools/lldb-perf/lib/Timer.cpp b/lldb/tools/lldb-perf/lib/Timer.cpp
index 4f4c623c2f0..bd912474aa2 100644
--- a/lldb/tools/lldb-perf/lib/Timer.cpp
+++ b/lldb/tools/lldb-perf/lib/Timer.cpp
@@ -11,37 +11,37 @@
 
 using namespace lldb_perf;
 
-TimeGauge::HPTime
-TimeGauge::now ()
+TimeGauge::TimeType
+TimeGauge::Now ()
 {
 	return high_resolution_clock::now();
 }
 
 TimeGauge::TimeGauge () :
 m_start(),
-m_state(TimeGauge::State::eTSNeverUsed)
+    m_state(TimeGauge::State::eNeverUsed)
 {
 }
 
 void
-TimeGauge::start ()
+TimeGauge::Start ()
 {
-	m_state = TimeGauge::State::eTSCounting;
-	m_start = now();
+	m_state = TimeGauge::State::eCounting;
+	m_start = Now();
 }
 
 double
-TimeGauge::stop ()
+TimeGauge::Stop ()
 {
-	auto stop = now();
-	assert(m_state == TimeGauge::State::eTSCounting && "cannot stop a non-started clock");
-	m_state = TimeGauge::State::eTSStopped;
+	auto stop = Now();
+	assert(m_state == TimeGauge::State::eCounting && "cannot stop a non-started clock");
+	m_state = TimeGauge::State::eStopped;
 	return (m_value = duration_cast<duration<double>>(stop-m_start).count());
 }
 
 double
-TimeGauge::value ()
+TimeGauge::GetValue ()
 {
-	assert(m_state == TimeGauge::State::eTSStopped && "clock must be used before you can evaluate it");
+	assert(m_state == TimeGauge::State::eStopped && "clock must be used before you can evaluate it");
 	return m_value;
 }
diff --git a/lldb/tools/lldb-perf/lib/Timer.h b/lldb/tools/lldb-perf/lib/Timer.h
index 4f8ac15f943..82bc68f1a10 100644
--- a/lldb/tools/lldb-perf/lib/Timer.h
+++ b/lldb/tools/lldb-perf/lib/Timer.h
@@ -22,34 +22,35 @@ class TimeGauge : public Gauge<double>
 private:
     enum class State
     {
-        eTSNeverUsed,
-        eTSCounting,
-        eTSStopped
+        eNeverUsed,
+        eCounting,
+        eStopped
     };
     
-    typedef high_resolution_clock::time_point HPTime;
-    HPTime m_start;
+    typedef high_resolution_clock::time_point TimeType;
+    TimeType m_start;
     double m_value;
     State m_state;
     
-    HPTime
-    now ();
+    TimeType
+    Now ();
     
 public:
     TimeGauge ();
     
     virtual
     ~TimeGauge ()
-    {}
+    {
+    }
     
     void
-    start ();
+    Start ();
     
     double
-    stop ();
+    Stop ();
     
     double
-    value ();
+    GetValue ();
 };
 }