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 <windows.h> 8#include <psapi.h> 9 10#include "base/logging.h" 11#include "base/sys_info.h" 12 13namespace base { 14 15// System pagesize. This value remains constant on x86/64 architectures. 16const int PAGESIZE_KB = 4; 17 18ProcessMetrics::~ProcessMetrics() { } 19 20// static 21ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) { 22 return new ProcessMetrics(process); 23} 24 25size_t ProcessMetrics::GetPagefileUsage() const { 26 PROCESS_MEMORY_COUNTERS pmc; 27 if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) { 28 return pmc.PagefileUsage; 29 } 30 return 0; 31} 32 33// Returns the peak space allocated for the pagefile, in bytes. 34size_t ProcessMetrics::GetPeakPagefileUsage() const { 35 PROCESS_MEMORY_COUNTERS pmc; 36 if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) { 37 return pmc.PeakPagefileUsage; 38 } 39 return 0; 40} 41 42// Returns the current working set size, in bytes. 43size_t ProcessMetrics::GetWorkingSetSize() const { 44 PROCESS_MEMORY_COUNTERS pmc; 45 if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) { 46 return pmc.WorkingSetSize; 47 } 48 return 0; 49} 50 51// Returns the peak working set size, in bytes. 52size_t ProcessMetrics::GetPeakWorkingSetSize() const { 53 PROCESS_MEMORY_COUNTERS pmc; 54 if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) { 55 return pmc.PeakWorkingSetSize; 56 } 57 return 0; 58} 59 60bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes, 61 size_t* shared_bytes) { 62 // PROCESS_MEMORY_COUNTERS_EX is not supported until XP SP2. 63 // GetProcessMemoryInfo() will simply fail on prior OS. So the requested 64 // information is simply not available. Hence, we will return 0 on unsupported 65 // OSes. Unlike most Win32 API, we don't need to initialize the "cb" member. 66 PROCESS_MEMORY_COUNTERS_EX pmcx; 67 if (private_bytes && 68 GetProcessMemoryInfo(process_, 69 reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmcx), 70 sizeof(pmcx))) { 71 *private_bytes = pmcx.PrivateUsage; 72 } 73 74 if (shared_bytes) { 75 WorkingSetKBytes ws_usage; 76 if (!GetWorkingSetKBytes(&ws_usage)) 77 return false; 78 79 *shared_bytes = ws_usage.shared * 1024; 80 } 81 82 return true; 83} 84 85void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const { 86 MEMORY_BASIC_INFORMATION mbi = {0}; 87 size_t committed_private = 0; 88 size_t committed_mapped = 0; 89 size_t committed_image = 0; 90 void* base_address = NULL; 91 while (VirtualQueryEx(process_, base_address, &mbi, sizeof(mbi)) == 92 sizeof(mbi)) { 93 if (mbi.State == MEM_COMMIT) { 94 if (mbi.Type == MEM_PRIVATE) { 95 committed_private += mbi.RegionSize; 96 } else if (mbi.Type == MEM_MAPPED) { 97 committed_mapped += mbi.RegionSize; 98 } else if (mbi.Type == MEM_IMAGE) { 99 committed_image += mbi.RegionSize; 100 } else { 101 NOTREACHED(); 102 } 103 } 104 void* new_base = (static_cast<BYTE*>(mbi.BaseAddress)) + mbi.RegionSize; 105 // Avoid infinite loop by weird MEMORY_BASIC_INFORMATION. 106 // If we query 64bit processes in a 32bit process, VirtualQueryEx() 107 // returns such data. 108 if (new_base <= base_address) { 109 usage->image = 0; 110 usage->mapped = 0; 111 usage->priv = 0; 112 return; 113 } 114 base_address = new_base; 115 } 116 usage->image = committed_image / 1024; 117 usage->mapped = committed_mapped / 1024; 118 usage->priv = committed_private / 1024; 119} 120 121bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const { 122 size_t ws_private = 0; 123 size_t ws_shareable = 0; 124 size_t ws_shared = 0; 125 126 DCHECK(ws_usage); 127 memset(ws_usage, 0, sizeof(*ws_usage)); 128 129 DWORD number_of_entries = 4096; // Just a guess. 130 PSAPI_WORKING_SET_INFORMATION* buffer = NULL; 131 int retries = 5; 132 for (;;) { 133 DWORD buffer_size = sizeof(PSAPI_WORKING_SET_INFORMATION) + 134 (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK)); 135 136 // if we can't expand the buffer, don't leak the previous 137 // contents or pass a NULL pointer to QueryWorkingSet 138 PSAPI_WORKING_SET_INFORMATION* new_buffer = 139 reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>( 140 realloc(buffer, buffer_size)); 141 if (!new_buffer) { 142 free(buffer); 143 return false; 144 } 145 buffer = new_buffer; 146 147 // Call the function once to get number of items 148 if (QueryWorkingSet(process_, buffer, buffer_size)) 149 break; // Success 150 151 if (GetLastError() != ERROR_BAD_LENGTH) { 152 free(buffer); 153 return false; 154 } 155 156 number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries); 157 158 // Maybe some entries are being added right now. Increase the buffer to 159 // take that into account. 160 number_of_entries = static_cast<DWORD>(number_of_entries * 1.25); 161 162 if (--retries == 0) { 163 free(buffer); // If we're looping, eventually fail. 164 return false; 165 } 166 } 167 168 // On windows 2000 the function returns 1 even when the buffer is too small. 169 // The number of entries that we are going to parse is the minimum between the 170 // size we allocated and the real number of entries. 171 number_of_entries = 172 std::min(number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries)); 173 for (unsigned int i = 0; i < number_of_entries; i++) { 174 if (buffer->WorkingSetInfo[i].Shared) { 175 ws_shareable++; 176 if (buffer->WorkingSetInfo[i].ShareCount > 1) 177 ws_shared++; 178 } else { 179 ws_private++; 180 } 181 } 182 183 ws_usage->priv = ws_private * PAGESIZE_KB; 184 ws_usage->shareable = ws_shareable * PAGESIZE_KB; 185 ws_usage->shared = ws_shared * PAGESIZE_KB; 186 free(buffer); 187 return true; 188} 189 190static uint64 FileTimeToUTC(const FILETIME& ftime) { 191 LARGE_INTEGER li; 192 li.LowPart = ftime.dwLowDateTime; 193 li.HighPart = ftime.dwHighDateTime; 194 return li.QuadPart; 195} 196 197double ProcessMetrics::GetCPUUsage() { 198 FILETIME creation_time; 199 FILETIME exit_time; 200 FILETIME kernel_time; 201 FILETIME user_time; 202 203 if (!GetProcessTimes(process_, &creation_time, &exit_time, 204 &kernel_time, &user_time)) { 205 // We don't assert here because in some cases (such as in the Task Manager) 206 // we may call this function on a process that has just exited but we have 207 // not yet received the notification. 208 return 0; 209 } 210 int64 system_time = (FileTimeToUTC(kernel_time) + FileTimeToUTC(user_time)) / 211 processor_count_; 212 TimeTicks time = TimeTicks::Now(); 213 214 if (last_system_time_ == 0) { 215 // First call, just set the last values. 216 last_system_time_ = system_time; 217 last_cpu_time_ = time; 218 return 0; 219 } 220 221 int64 system_time_delta = system_time - last_system_time_; 222 // FILETIME is in 100-nanosecond units, so this needs microseconds times 10. 223 int64 time_delta = (time - last_cpu_time_).InMicroseconds() * 10; 224 DCHECK_NE(0U, time_delta); 225 if (time_delta == 0) 226 return 0; 227 228 // We add time_delta / 2 so the result is rounded. 229 int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) / 230 time_delta); 231 232 last_system_time_ = system_time; 233 last_cpu_time_ = time; 234 235 return cpu; 236} 237 238bool ProcessMetrics::CalculateFreeMemory(FreeMBytes* free) const { 239 const SIZE_T kTopAddress = 0x7F000000; 240 const SIZE_T kMegabyte = 1024 * 1024; 241 SIZE_T accumulated = 0; 242 243 MEMORY_BASIC_INFORMATION largest = {0}; 244 UINT_PTR scan = 0; 245 while (scan < kTopAddress) { 246 MEMORY_BASIC_INFORMATION info; 247 if (!::VirtualQueryEx(process_, reinterpret_cast<void*>(scan), 248 &info, sizeof(info))) 249 return false; 250 if (info.State == MEM_FREE) { 251 accumulated += info.RegionSize; 252 if (info.RegionSize > largest.RegionSize) 253 largest = info; 254 } 255 scan += info.RegionSize; 256 } 257 free->largest = largest.RegionSize / kMegabyte; 258 free->largest_ptr = largest.BaseAddress; 259 free->total = accumulated / kMegabyte; 260 return true; 261} 262 263bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const { 264 return GetProcessIoCounters(process_, io_counters) != FALSE; 265} 266 267ProcessMetrics::ProcessMetrics(ProcessHandle process) 268 : process_(process), 269 processor_count_(base::SysInfo::NumberOfProcessors()), 270 last_system_time_(0) { 271} 272 273// GetPerformanceInfo is not available on WIN2K. So we'll 274// load it on-the-fly. 275const wchar_t kPsapiDllName[] = L"psapi.dll"; 276typedef BOOL (WINAPI *GetPerformanceInfoFunction) ( 277 PPERFORMANCE_INFORMATION pPerformanceInformation, 278 DWORD cb); 279 280// Beware of races if called concurrently from multiple threads. 281static BOOL InternalGetPerformanceInfo( 282 PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb) { 283 static GetPerformanceInfoFunction GetPerformanceInfo_func = NULL; 284 if (!GetPerformanceInfo_func) { 285 HMODULE psapi_dll = ::GetModuleHandle(kPsapiDllName); 286 if (psapi_dll) 287 GetPerformanceInfo_func = reinterpret_cast<GetPerformanceInfoFunction>( 288 GetProcAddress(psapi_dll, "GetPerformanceInfo")); 289 290 if (!GetPerformanceInfo_func) { 291 // The function could be loaded! 292 memset(pPerformanceInformation, 0, cb); 293 return FALSE; 294 } 295 } 296 return GetPerformanceInfo_func(pPerformanceInformation, cb); 297} 298 299size_t GetSystemCommitCharge() { 300 // Get the System Page Size. 301 SYSTEM_INFO system_info; 302 GetSystemInfo(&system_info); 303 304 PERFORMANCE_INFORMATION info; 305 if (!InternalGetPerformanceInfo(&info, sizeof(info))) { 306 DLOG(ERROR) << "Failed to fetch internal performance info."; 307 return 0; 308 } 309 return (info.CommitTotal * system_info.dwPageSize) / 1024; 310} 311 312} // namespace base 313