| //===-- MemoryGauge.cpp -----------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "MemoryGauge.h" |
| #include "lldb/lldb-forward.h" |
| #include <assert.h> |
| #include <cmath> |
| #include <mach/mach.h> |
| #include <mach/task.h> |
| #include <mach/mach_traps.h> |
| |
| using namespace lldb_perf; |
| |
| 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::operator = (const MemoryStats& rhs) |
| { |
| if (this != &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) |
| { |
| 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 + (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 n) |
| { |
| MemoryStats result(*this); |
| result.m_virtual_size /= n; |
| result.m_resident_size /= n; |
| result.m_max_resident_size /= n; |
| return result; |
| } |
| |
| 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); |
| } |
| |
| Results::ResultSP |
| MemoryStats::GetResult (const char *name, const char *description) const |
| { |
| std::unique_ptr<Results::Dictionary> dict_ap (new Results::Dictionary (name, NULL)); |
| dict_ap->AddUnsigned("resident", NULL, GetResidentSize()); |
| dict_ap->AddUnsigned("max_resident", NULL, GetMaxResidentSize()); |
| return Results::ResultSP(dict_ap.release()); |
| } |
| |
| MemoryGauge::ValueType |
| MemoryGauge::Now () |
| { |
| task_t task = mach_task_self(); |
| mach_task_basic_info_data_t taskBasicInfo; |
| mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT; |
| 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; |
| } |
| |
| MemoryGauge::MemoryGauge () : |
| m_state(MemoryGauge::State::eNeverUsed), |
| m_start(), |
| m_delta() |
| { |
| } |
| |
| void |
| MemoryGauge::Start () |
| { |
| m_state = MemoryGauge::State::eCounting; |
| m_start = Now(); |
| } |
| |
| MemoryGauge::ValueType |
| MemoryGauge::Stop () |
| { |
| m_stop = Now(); |
| assert(m_state == MemoryGauge::State::eCounting && "cannot stop a non-started gauge"); |
| m_state = MemoryGauge::State::eStopped; |
| m_delta = m_stop - m_start; |
| return m_delta; |
| } |
| |
| |
| MemoryGauge::ValueType |
| MemoryGauge::GetDeltaValue () const |
| { |
| assert(m_state == MemoryGauge::State::eStopped && "gauge must be used before you can evaluate it"); |
| return m_delta; |
| } |
| |
| template <> |
| Results::ResultSP |
| lldb_perf::GetResult (const char *description, MemoryStats value) |
| { |
| return value.GetResult (NULL, description); |
| } |
| |
| MemoryStats |
| sqrt (const MemoryStats& arg) |
| { |
| long double virt_size = arg.GetVirtualSize(); |
| long double resident_size = arg.GetResidentSize(); |
| long double max_resident_size = arg.GetMaxResidentSize(); |
| |
| virt_size = sqrtl(virt_size); |
| resident_size = sqrtl(resident_size); |
| max_resident_size = sqrtl(max_resident_size); |
| |
| return MemoryStats(virt_size,resident_size,max_resident_size); |
| } |