Making MemoryGauge work by fixing a Mach API call mistake - saving (and dumping) more information out of the task_info call

llvm-svn: 177580

lldb/tools/lldb-perf/lib/Measurement.h

@@ -12,6 +12,7 @@
 #include "Gauge.h"
 #include "Timer.h"
 #include "Metric.h"
+#include "MemoryGauge.h"
 
 namespace lldb_perf
 {
@@ -90,6 +91,32 @@ public:
     }
 };
 
+template <typename Action>
+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
+    operator () (Args... args)
+    {
+        Measurement<MemoryGauge,Action>::operator()(args...);
+    }
+};
+    
 }
 
 #endif /* defined(__PerfTestDriver__Measurement__) */

lldb/tools/lldb-perf/lib/MemoryGauge.cpp

@@ -8,18 +8,69 @@
 
 #include "MemoryGauge.h"
 #include <assert.h>
+#include <mach/mach.h>
 #include <mach/task.h>
+#include <mach/mach_traps.h>
 
 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 (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)
+    {
+        m_virtual_size = rhs.m_virtual_size;
+        m_resident_size = rhs.m_resident_size;
+        m_max_resident_size = rhs.m_max_resident_size;
+    }
+    return *this;
+}
+
+MemoryStats&
+MemoryStats::operator += (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;
+    return *this;
+}
+
+MemoryStats
+MemoryStats::operator - (const MemoryStats& rhs)
+{
+    return MemoryStats(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::operator / (size_t rhs)
+{
+    m_virtual_size /= rhs;
+    m_resident_size /= rhs;
+    m_max_resident_size /= rhs;
+    return *this;
+}
+
 MemoryGauge::SizeType
 MemoryGauge::now ()
 {
-    task_t task = MACH_PORT_NULL;
+    task_t task = mach_task_self();
     mach_task_basic_info_data_t taskBasicInfo;
     mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
-    if (task_info(task, MACH_TASK_BASIC_INFO, (task_info_t) & taskBasicInfo, &count) == KERN_SUCCESS) {
-        return taskBasicInfo.virtual_size;
+    auto task_info_ret = task_info(task, MACH_TASK_BASIC_INFO, (task_info_t) & taskBasicInfo, &count);
+    if (task_info_ret == KERN_SUCCESS) {
+        return MemoryStats(taskBasicInfo.virtual_size, taskBasicInfo.resident_size, taskBasicInfo.resident_size_max);
     }
     return 0;
 }

lldb/tools/lldb-perf/lib/MemoryGauge.h

@@ -15,7 +15,68 @@
 
 namespace lldb_perf
 {
-class MemoryGauge : public Gauge<mach_vm_size_t>
+class MemoryStats
+{
+public:
+    MemoryStats ();
+    MemoryStats (mach_vm_size_t,mach_vm_size_t = 0, mach_vm_size_t = 0);
+    MemoryStats (const MemoryStats& rhs);
+    
+    MemoryStats&
+    operator = (const MemoryStats& rhs);
+
+    MemoryStats&
+    operator += (const MemoryStats& rhs);
+
+    MemoryStats
+    operator - (const MemoryStats& rhs);
+
+    MemoryStats&
+    operator / (size_t rhs);
+    
+    mach_vm_size_t
+    GetVirtualSize ()
+    {
+        return m_virtual_size;
+    }
+    
+    mach_vm_size_t
+    GetResidentSize ()
+    {
+        return m_resident_size;
+    }
+    
+    mach_vm_size_t
+    GetMaxResidentSize ()
+    {
+        return m_max_resident_size;
+    }
+    
+    void
+    SetVirtualSize (mach_vm_size_t vs)
+    {
+        m_virtual_size = vs;
+    }
+    
+    void
+    SetResidentSize (mach_vm_size_t rs)
+    {
+        m_resident_size = rs;
+    }
+    
+    void
+    SetMaxResidentSize (mach_vm_size_t mrs)
+    {
+        m_max_resident_size = mrs;
+    }
+    
+private:
+    mach_vm_size_t m_virtual_size;
+    mach_vm_size_t m_resident_size;
+    mach_vm_size_t m_max_resident_size;
+};
+
+class MemoryGauge : public Gauge<MemoryStats>
 {
 private:
     enum class State

lldb/tools/lldb-perf/lib/Metric.cpp

@@ -11,6 +11,7 @@
 #include "CFCMutableArray.h"
 #include "CFCMutableDictionary.h"
 #include "CFCString.h"
+#include "MemoryGauge.h"
 
 using namespace lldb_perf;
 
@@ -70,8 +71,8 @@ Metric<T>::description ()
     return m_description.c_str();
 }
 
-template <class T>
-void Metric<T>::WriteImpl (CFCMutableArray& parent, identity<double>)
+template <>
+void Metric<double>::WriteImpl (CFCMutableArray& parent, identity<double>)
 {
     CFCMutableDictionary dict;
     dict.AddValueCString(CFCString("name").get(),name(), true);
@@ -80,15 +81,24 @@ void Metric<T>::WriteImpl (CFCMutableArray& parent, identity<double>)
     parent.AppendValue(dict.get(), true);
 }
 
-template <class T>
-void Metric<T>::WriteImpl (CFCMutableArray& parent, identity<mach_vm_size_t>)
+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.AddValueUInt64(CFCString("value").get(),this->average(), true);
+    CFCMutableDictionary value;
+
+    auto avg = this->average();
+    
+    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);
+    
     parent.AppendValue(dict.get(), true);
 }
 
 template class lldb_perf::Metric<double>;
-template class lldb_perf::Metric<mach_vm_size_t>;
+template class lldb_perf::Metric<MemoryStats>;

lldb/tools/lldb-perf/lib/Metric.h

@@ -17,6 +17,7 @@
 
 namespace lldb_perf
 {
+class MemoryStats;
 class WriteToPList
 {
 public:
@@ -64,7 +65,7 @@ private:
     
     void WriteImpl (CFCMutableArray& parent, identity<double>);
 
-    void WriteImpl (CFCMutableArray& parent, identity<mach_vm_size_t>);
+    void WriteImpl (CFCMutableArray& parent, identity<MemoryStats>);
     
     std::string m_name;
     std::string m_description;

lldb/tools/lldb-perf/lib/TestCase.h

@@ -102,6 +102,12 @@ public:
         return TimeMeasurement<A> (a,name, description);
     }
     
+    template <typename A>
+    MemoryMeasurement<A> CreateMemoryMeasurement (A a, const char* name = NULL, const char* description = NULL)
+    {
+        return MemoryMeasurement<A> (a,name, description);
+    }
+    
     static void
     Run (TestCase& test, int argc, const char** argv);