1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "base/process/process_metrics.h"
8 #include <mach/mach_vm.h>
9 #include <mach/shared_region.h>
10 #include <sys/sysctl.h>
12 #include "base/containers/hash_tables.h"
13 #include "base/logging.h"
14 #include "base/mac/mach_logging.h"
15 #include "base/mac/scoped_mach_port.h"
16 #include "base/sys_info.h"
18 #if !defined(TASK_POWER_INFO)
19 // Doesn't exist in the 10.6 or 10.7 SDKs.
20 #define TASK_POWER_INFO 21
21 struct task_power_info
{
23 uint64_t total_system
;
24 uint64_t task_interrupt_wakeups
;
25 uint64_t task_platform_idle_wakeups
;
26 uint64_t task_timer_wakeups_bin_1
;
27 uint64_t task_timer_wakeups_bin_2
;
29 typedef struct task_power_info task_power_info_data_t
;
30 typedef struct task_power_info
*task_power_info_t
;
31 #define TASK_POWER_INFO_COUNT ((mach_msg_type_number_t) \
32 (sizeof (task_power_info_data_t) / sizeof (natural_t)))
39 bool GetTaskInfo(mach_port_t task
, task_basic_info_64
* task_info_data
) {
40 if (task
== MACH_PORT_NULL
)
42 mach_msg_type_number_t count
= TASK_BASIC_INFO_64_COUNT
;
43 kern_return_t kr
= task_info(task
,
45 reinterpret_cast<task_info_t
>(task_info_data
),
47 // Most likely cause for failure: |task| is a zombie.
48 return kr
== KERN_SUCCESS
;
51 bool GetCPUTypeForProcess(pid_t pid
, cpu_type_t
* cpu_type
) {
52 size_t len
= sizeof(*cpu_type
);
53 int result
= sysctlbyname("sysctl.proc_cputype",
59 DPLOG(ERROR
) << "sysctlbyname(""sysctl.proc_cputype"")";
66 bool IsAddressInSharedRegion(mach_vm_address_t addr
, cpu_type_t type
) {
67 if (type
== CPU_TYPE_I386
) {
68 return addr
>= SHARED_REGION_BASE_I386
&&
69 addr
< (SHARED_REGION_BASE_I386
+ SHARED_REGION_SIZE_I386
);
70 } else if (type
== CPU_TYPE_X86_64
) {
71 return addr
>= SHARED_REGION_BASE_X86_64
&&
72 addr
< (SHARED_REGION_BASE_X86_64
+ SHARED_REGION_SIZE_X86_64
);
80 // Getting a mach task from a pid for another process requires permissions in
81 // general, so there doesn't really seem to be a way to do these (and spinning
82 // up ps to fetch each stats seems dangerous to put in a base api for anyone to
83 // call). Child processes ipc their port, so return something if available,
84 // otherwise return 0.
87 ProcessMetrics
* ProcessMetrics::CreateProcessMetrics(
88 ProcessHandle process
,
89 ProcessMetrics::PortProvider
* port_provider
) {
90 return new ProcessMetrics(process
, port_provider
);
93 size_t ProcessMetrics::GetPagefileUsage() const {
94 task_basic_info_64 task_info_data
;
95 if (!GetTaskInfo(TaskForPid(process_
), &task_info_data
))
97 return task_info_data
.virtual_size
;
100 size_t ProcessMetrics::GetPeakPagefileUsage() const {
104 size_t ProcessMetrics::GetWorkingSetSize() const {
105 task_basic_info_64 task_info_data
;
106 if (!GetTaskInfo(TaskForPid(process_
), &task_info_data
))
108 return task_info_data
.resident_size
;
111 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
115 // This is a rough approximation of the algorithm that libtop uses.
116 // private_bytes is the size of private resident memory.
117 // shared_bytes is the size of shared resident memory.
118 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes
,
119 size_t* shared_bytes
) {
120 size_t private_pages_count
= 0;
121 size_t shared_pages_count
= 0;
123 if (!private_bytes
&& !shared_bytes
)
126 mach_port_t task
= TaskForPid(process_
);
127 if (task
== MACH_PORT_NULL
) {
128 DLOG(ERROR
) << "Invalid process";
133 if (!GetCPUTypeForProcess(process_
, &cpu_type
))
136 // The same region can be referenced multiple times. To avoid double counting
137 // we need to keep track of which regions we've already counted.
138 base::hash_set
<int> seen_objects
;
140 // We iterate through each VM region in the task's address map. For shared
141 // memory we add up all the pages that are marked as shared. Like libtop we
142 // try to avoid counting pages that are also referenced by other tasks. Since
143 // we don't have access to the VM regions of other tasks the only hint we have
144 // is if the address is in the shared region area.
146 // Private memory is much simpler. We simply count the pages that are marked
147 // as private or copy on write (COW).
149 // See libtop_update_vm_regions in
150 // http://www.opensource.apple.com/source/top/top-67/libtop.c
151 mach_vm_size_t size
= 0;
152 for (mach_vm_address_t address
= MACH_VM_MIN_ADDRESS
;; address
+= size
) {
153 vm_region_top_info_data_t info
;
154 mach_msg_type_number_t info_count
= VM_REGION_TOP_INFO_COUNT
;
155 mach_port_t object_name
;
156 kern_return_t kr
= mach_vm_region(task
,
160 reinterpret_cast<vm_region_info_t
>(&info
),
163 if (kr
== KERN_INVALID_ADDRESS
) {
164 // We're at the end of the address space.
166 } else if (kr
!= KERN_SUCCESS
) {
167 MACH_DLOG(ERROR
, kr
) << "mach_vm_region";
171 // The kernel always returns a null object for VM_REGION_TOP_INFO, but
172 // balance it with a deallocate in case this ever changes. See 10.9.2
173 // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region.
174 mach_port_deallocate(mach_task_self(), object_name
);
176 if (IsAddressInSharedRegion(address
, cpu_type
) &&
177 info
.share_mode
!= SM_PRIVATE
)
180 if (info
.share_mode
== SM_COW
&& info
.ref_count
== 1)
181 info
.share_mode
= SM_PRIVATE
;
183 switch (info
.share_mode
) {
185 private_pages_count
+= info
.private_pages_resident
;
186 private_pages_count
+= info
.shared_pages_resident
;
189 private_pages_count
+= info
.private_pages_resident
;
192 if (seen_objects
.count(info
.obj_id
) == 0) {
193 // Only count the first reference to this region.
194 seen_objects
.insert(info
.obj_id
);
195 shared_pages_count
+= info
.shared_pages_resident
;
204 *private_bytes
= private_pages_count
* PAGE_SIZE
;
206 *shared_bytes
= shared_pages_count
* PAGE_SIZE
;
211 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes
* usage
) const {
212 WorkingSetKBytes unused
;
213 if (!GetCommittedAndWorkingSetKBytes(usage
, &unused
)) {
214 *usage
= CommittedKBytes();
218 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes
* ws_usage
) const {
219 CommittedKBytes unused
;
220 return GetCommittedAndWorkingSetKBytes(&unused
, ws_usage
);
223 bool ProcessMetrics::GetCommittedAndWorkingSetKBytes(
224 CommittedKBytes
* usage
,
225 WorkingSetKBytes
* ws_usage
) const {
226 task_basic_info_64 task_info_data
;
227 if (!GetTaskInfo(TaskForPid(process_
), &task_info_data
))
230 usage
->priv
= task_info_data
.virtual_size
/ 1024;
234 ws_usage
->priv
= task_info_data
.resident_size
/ 1024;
235 ws_usage
->shareable
= 0;
236 ws_usage
->shared
= 0;
241 #define TIME_VALUE_TO_TIMEVAL(a, r) do { \
242 (r)->tv_sec = (a)->seconds; \
243 (r)->tv_usec = (a)->microseconds; \
246 double ProcessMetrics::GetCPUUsage() {
247 mach_port_t task
= TaskForPid(process_
);
248 if (task
== MACH_PORT_NULL
)
251 // Libtop explicitly loops over the threads (libtop_pinfo_update_cpu_usage()
252 // in libtop.c), but this is more concise and gives the same results:
253 task_thread_times_info thread_info_data
;
254 mach_msg_type_number_t thread_info_count
= TASK_THREAD_TIMES_INFO_COUNT
;
255 kern_return_t kr
= task_info(task
,
256 TASK_THREAD_TIMES_INFO
,
257 reinterpret_cast<task_info_t
>(&thread_info_data
),
259 if (kr
!= KERN_SUCCESS
) {
260 // Most likely cause: |task| is a zombie.
264 task_basic_info_64 task_info_data
;
265 if (!GetTaskInfo(task
, &task_info_data
))
268 /* Set total_time. */
269 // thread info contains live time...
270 struct timeval user_timeval
, system_timeval
, task_timeval
;
271 TIME_VALUE_TO_TIMEVAL(&thread_info_data
.user_time
, &user_timeval
);
272 TIME_VALUE_TO_TIMEVAL(&thread_info_data
.system_time
, &system_timeval
);
273 timeradd(&user_timeval
, &system_timeval
, &task_timeval
);
275 // ... task info contains terminated time.
276 TIME_VALUE_TO_TIMEVAL(&task_info_data
.user_time
, &user_timeval
);
277 TIME_VALUE_TO_TIMEVAL(&task_info_data
.system_time
, &system_timeval
);
278 timeradd(&user_timeval
, &task_timeval
, &task_timeval
);
279 timeradd(&system_timeval
, &task_timeval
, &task_timeval
);
281 TimeTicks time
= TimeTicks::Now();
282 int64 task_time
= TimeValToMicroseconds(task_timeval
);
284 if (last_system_time_
== 0) {
285 // First call, just set the last values.
286 last_cpu_time_
= time
;
287 last_system_time_
= task_time
;
291 int64 system_time_delta
= task_time
- last_system_time_
;
292 int64 time_delta
= (time
- last_cpu_time_
).InMicroseconds();
293 DCHECK_NE(0U, time_delta
);
297 last_cpu_time_
= time
;
298 last_system_time_
= task_time
;
300 return static_cast<double>(system_time_delta
* 100.0) / time_delta
;
303 int ProcessMetrics::GetIdleWakeupsPerSecond() {
304 mach_port_t task
= TaskForPid(process_
);
305 if (task
== MACH_PORT_NULL
)
308 task_power_info power_info_data
;
309 mach_msg_type_number_t power_info_count
= TASK_POWER_INFO_COUNT
;
310 kern_return_t kr
= task_info(task
,
312 reinterpret_cast<task_info_t
>(&power_info_data
),
314 if (kr
!= KERN_SUCCESS
) {
315 // Most likely cause: |task| is a zombie, or this is on a pre-10.8.4 system
316 // where TASK_POWER_INFO isn't supported yet.
319 return CalculateIdleWakeupsPerSecond(
320 power_info_data
.task_platform_idle_wakeups
);
323 bool ProcessMetrics::GetIOCounters(IoCounters
* io_counters
) const {
327 ProcessMetrics::ProcessMetrics(ProcessHandle process
,
328 ProcessMetrics::PortProvider
* port_provider
)
330 last_system_time_(0),
331 last_absolute_idle_wakeups_(0),
332 port_provider_(port_provider
) {
333 processor_count_
= SysInfo::NumberOfProcessors();
336 mach_port_t
ProcessMetrics::TaskForPid(ProcessHandle process
) const {
337 mach_port_t task
= MACH_PORT_NULL
;
339 task
= port_provider_
->TaskForPid(process_
);
340 if (task
== MACH_PORT_NULL
&& process_
== getpid())
341 task
= mach_task_self();
345 // Bytes committed by the system.
346 size_t GetSystemCommitCharge() {
347 base::mac::ScopedMachSendRight
host(mach_host_self());
348 mach_msg_type_number_t count
= HOST_VM_INFO_COUNT
;
349 vm_statistics_data_t data
;
350 kern_return_t kr
= host_statistics(host
, HOST_VM_INFO
,
351 reinterpret_cast<host_info_t
>(&data
),
353 if (kr
!= KERN_SUCCESS
) {
354 MACH_DLOG(WARNING
, kr
) << "host_statistics";
358 return (data
.active_count
* PAGE_SIZE
) / 1024;