1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
//===-- 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 <assert.h>
#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 / (size_t n)
{
m_virtual_size /= n;
m_resident_size /= n;
m_max_resident_size /= n;
return *this;
}
MemoryGauge::SizeType
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_start(),
m_state(MemoryGauge::State::eNeverUsed)
{
}
void
MemoryGauge::Start ()
{
m_state = MemoryGauge::State::eCounting;
m_start = Now();
}
MemoryGauge::SizeType
MemoryGauge::Stop ()
{
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::GetValue ()
{
assert(m_state == MemoryGauge::State::eStopped && "gauge must be used before you can evaluate it");
return m_value;
}
|
