MemoryGauge.cpp   [plain text]

//===-- 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);
}