Added llvm into exceptions as we can't add README.chromium into 3rd party repository
[chromium-blink-merge.git] / base / process / process_metrics_mac.cc
blobf84b435a109fee2d0c598050e166fea65d459870
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"
7 #include <mach/mach.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 {
22 uint64_t total_user;
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)))
33 #endif
35 namespace base {
37 namespace {
39 bool GetTaskInfo(mach_port_t task, task_basic_info_64* task_info_data) {
40 if (task == MACH_PORT_NULL)
41 return false;
42 mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT;
43 kern_return_t kr = task_info(task,
44 TASK_BASIC_INFO_64,
45 reinterpret_cast<task_info_t>(task_info_data),
46 &count);
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",
54 cpu_type,
55 &len,
56 NULL,
57 0);
58 if (result != 0) {
59 DPLOG(ERROR) << "sysctlbyname(""sysctl.proc_cputype"")";
60 return false;
63 return true;
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);
73 } else {
74 return false;
78 } // namespace
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.
86 // static
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))
96 return 0;
97 return task_info_data.virtual_size;
100 size_t ProcessMetrics::GetPeakPagefileUsage() const {
101 return 0;
104 size_t ProcessMetrics::GetWorkingSetSize() const {
105 task_basic_info_64 task_info_data;
106 if (!GetTaskInfo(TaskForPid(process_), &task_info_data))
107 return 0;
108 return task_info_data.resident_size;
111 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
112 return 0;
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)
124 return true;
126 mach_port_t task = TaskForPid(process_);
127 if (task == MACH_PORT_NULL) {
128 DLOG(ERROR) << "Invalid process";
129 return false;
132 cpu_type_t cpu_type;
133 if (!GetCPUTypeForProcess(process_, &cpu_type))
134 return false;
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,
157 &address,
158 &size,
159 VM_REGION_TOP_INFO,
160 reinterpret_cast<vm_region_info_t>(&info),
161 &info_count,
162 &object_name);
163 if (kr == KERN_INVALID_ADDRESS) {
164 // We're at the end of the address space.
165 break;
166 } else if (kr != KERN_SUCCESS) {
167 MACH_DLOG(ERROR, kr) << "mach_vm_region";
168 return false;
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)
178 continue;
180 if (info.share_mode == SM_COW && info.ref_count == 1)
181 info.share_mode = SM_PRIVATE;
183 switch (info.share_mode) {
184 case SM_PRIVATE:
185 private_pages_count += info.private_pages_resident;
186 private_pages_count += info.shared_pages_resident;
187 break;
188 case SM_COW:
189 private_pages_count += info.private_pages_resident;
190 // Fall through
191 case SM_SHARED:
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;
197 break;
198 default:
199 break;
203 if (private_bytes)
204 *private_bytes = private_pages_count * PAGE_SIZE;
205 if (shared_bytes)
206 *shared_bytes = shared_pages_count * PAGE_SIZE;
208 return true;
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))
228 return false;
230 usage->priv = task_info_data.virtual_size / 1024;
231 usage->mapped = 0;
232 usage->image = 0;
234 ws_usage->priv = task_info_data.resident_size / 1024;
235 ws_usage->shareable = 0;
236 ws_usage->shared = 0;
238 return true;
241 #define TIME_VALUE_TO_TIMEVAL(a, r) do { \
242 (r)->tv_sec = (a)->seconds; \
243 (r)->tv_usec = (a)->microseconds; \
244 } while (0)
246 double ProcessMetrics::GetCPUUsage() {
247 mach_port_t task = TaskForPid(process_);
248 if (task == MACH_PORT_NULL)
249 return 0;
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),
258 &thread_info_count);
259 if (kr != KERN_SUCCESS) {
260 // Most likely cause: |task| is a zombie.
261 return 0;
264 task_basic_info_64 task_info_data;
265 if (!GetTaskInfo(task, &task_info_data))
266 return 0;
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;
288 return 0;
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);
294 if (time_delta == 0)
295 return 0;
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)
306 return 0;
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,
311 TASK_POWER_INFO,
312 reinterpret_cast<task_info_t>(&power_info_data),
313 &power_info_count);
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.
317 return 0;
319 return CalculateIdleWakeupsPerSecond(
320 power_info_data.task_platform_idle_wakeups);
323 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
324 return false;
327 ProcessMetrics::ProcessMetrics(ProcessHandle process,
328 ProcessMetrics::PortProvider* port_provider)
329 : process_(process),
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;
338 if (port_provider_)
339 task = port_provider_->TaskForPid(process_);
340 if (task == MACH_PORT_NULL && process_ == getpid())
341 task = mach_task_self();
342 return task;
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),
352 &count);
353 if (kr != KERN_SUCCESS) {
354 MACH_DLOG(WARNING, kr) << "host_statistics";
355 return 0;
358 return (data.active_count * PAGE_SIZE) / 1024;
361 } // namespace base