| OLD | NEW |
|---|
| (Empty) |
| 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. | |
| 4 | |
| 5 #include "base/process/process_metrics.h" | |
| 6 | |
| 7 #include <mach/mach.h> | |
| 8 #include <mach/mach_vm.h> | |
| 9 #include <mach/shared_region.h> | |
| 10 #include <sys/sysctl.h> | |
| 11 | |
| 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" | |
| 17 | |
| 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; | |
| 28 }; | |
| 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 | |
| 34 | |
| 35 namespace base { | |
| 36 | |
| 37 namespace { | |
| 38 | |
| 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; | |
| 49 } | |
| 50 | |
| 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; | |
| 61 } | |
| 62 | |
| 63 return true; | |
| 64 } | |
| 65 | |
| 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; | |
| 75 } | |
| 76 } | |
| 77 | |
| 78 } // namespace | |
| 79 | |
| 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. | |
| 85 | |
| 86 // static | |
| 87 ProcessMetrics* ProcessMetrics::CreateProcessMetrics( | |
| 88 ProcessHandle process, | |
| 89 ProcessMetrics::PortProvider* port_provider) { | |
| 90 return new ProcessMetrics(process, port_provider); | |
| 91 } | |
| 92 | |
| 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; | |
| 98 } | |
| 99 | |
| 100 size_t ProcessMetrics::GetPeakPagefileUsage() const { | |
| 101 return 0; | |
| 102 } | |
| 103 | |
| 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; | |
| 109 } | |
| 110 | |
| 111 size_t ProcessMetrics::GetPeakWorkingSetSize() const { | |
| 112 return 0; | |
| 113 } | |
| 114 | |
| 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; | |
| 122 | |
| 123 if (!private_bytes && !shared_bytes) | |
| 124 return true; | |
| 125 | |
| 126 mach_port_t task = TaskForPid(process_); | |
| 127 if (task == MACH_PORT_NULL) { | |
| 128 DLOG(ERROR) << "Invalid process"; | |
| 129 return false; | |
| 130 } | |
| 131 | |
| 132 cpu_type_t cpu_type; | |
| 133 if (!GetCPUTypeForProcess(process_, &cpu_type)) | |
| 134 return false; | |
| 135 | |
| 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; | |
| 139 | |
| 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. | |
| 145 // | |
| 146 // Private memory is much simpler. We simply count the pages that are marked | |
| 147 // as private or copy on write (COW). | |
| 148 // | |
| 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; | |
| 169 } | |
| 170 | |
| 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); | |
| 175 | |
| 176 if (IsAddressInSharedRegion(address, cpu_type) && | |
| 177 info.share_mode != SM_PRIVATE) | |
| 178 continue; | |
| 179 | |
| 180 if (info.share_mode == SM_COW && info.ref_count == 1) | |
| 181 info.share_mode = SM_PRIVATE; | |
| 182 | |
| 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; | |
| 196 } | |
| 197 break; | |
| 198 default: | |
| 199 break; | |
| 200 } | |
| 201 } | |
| 202 | |
| 203 if (private_bytes) | |
| 204 *private_bytes = private_pages_count * PAGE_SIZE; | |
| 205 if (shared_bytes) | |
| 206 *shared_bytes = shared_pages_count * PAGE_SIZE; | |
| 207 | |
| 208 return true; | |
| 209 } | |
| 210 | |
| 211 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const { | |
| 212 WorkingSetKBytes unused; | |
| 213 if (!GetCommittedAndWorkingSetKBytes(usage, &unused)) { | |
| 214 *usage = CommittedKBytes(); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const { | |
| 219 CommittedKBytes unused; | |
| 220 return GetCommittedAndWorkingSetKBytes(&unused, ws_usage); | |
| 221 } | |
| 222 | |
| 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; | |
| 229 | |
| 230 usage->priv = task_info_data.virtual_size / 1024; | |
| 231 usage->mapped = 0; | |
| 232 usage->image = 0; | |
| 233 | |
| 234 ws_usage->priv = task_info_data.resident_size / 1024; | |
| 235 ws_usage->shareable = 0; | |
| 236 ws_usage->shared = 0; | |
| 237 | |
| 238 return true; | |
| 239 } | |
| 240 | |
| 241 #define TIME_VALUE_TO_TIMEVAL(a, r) do { \ | |
| 242 (r)->tv_sec = (a)->seconds; \ | |
| 243 (r)->tv_usec = (a)->microseconds; \ | |
| 244 } while (0) | |
| 245 | |
| 246 double ProcessMetrics::GetCPUUsage() { | |
| 247 mach_port_t task = TaskForPid(process_); | |
| 248 if (task == MACH_PORT_NULL) | |
| 249 return 0; | |
| 250 | |
| 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; | |
| 262 } | |
| 263 | |
| 264 task_basic_info_64 task_info_data; | |
| 265 if (!GetTaskInfo(task, &task_info_data)) | |
| 266 return 0; | |
| 267 | |
| 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); | |
| 274 | |
| 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); | |
| 280 | |
| 281 TimeTicks time = TimeTicks::Now(); | |
| 282 int64 task_time = TimeValToMicroseconds(task_timeval); | |
| 283 | |
| 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; | |
| 289 } | |
| 290 | |
| 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; | |
| 296 | |
| 297 last_cpu_time_ = time; | |
| 298 last_system_time_ = task_time; | |
| 299 | |
| 300 return static_cast<double>(system_time_delta * 100.0) / time_delta; | |
| 301 } | |
| 302 | |
| 303 int ProcessMetrics::GetIdleWakeupsPerSecond() { | |
| 304 mach_port_t task = TaskForPid(process_); | |
| 305 if (task == MACH_PORT_NULL) | |
| 306 return 0; | |
| 307 | |
| 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; | |
| 318 } | |
| 319 return CalculateIdleWakeupsPerSecond( | |
| 320 power_info_data.task_platform_idle_wakeups); | |
| 321 } | |
| 322 | |
| 323 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const { | |
| 324 return false; | |
| 325 } | |
| 326 | |
| 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(); | |
| 334 } | |
| 335 | |
| 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; | |
| 343 } | |
| 344 | |
| 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; | |
| 356 } | |
| 357 | |
| 358 return (data.active_count * PAGE_SIZE) / 1024; | |
| 359 } | |
| 360 | |
| 361 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
