process_metrics_win.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
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 now;
199  FILETIME creation_time;
200  FILETIME exit_time;
201  FILETIME kernel_time;
202  FILETIME user_time;
203
204  GetSystemTimeAsFileTime(&now);
205
206  if (!GetProcessTimes(process_, &creation_time, &exit_time,
207                       &kernel_time, &user_time)) {
208    // We don't assert here because in some cases (such as in the Task Manager)
209    // we may call this function on a process that has just exited but we have
210    // not yet received the notification.
211    return 0;
212  }
213  int64 system_time = (FileTimeToUTC(kernel_time) + FileTimeToUTC(user_time)) /
214                        processor_count_;
215  int64 time = FileTimeToUTC(now);
216
217  if ((last_system_time_ == 0) || (last_cpu_time_ == 0)) {
218    // First call, just set the last values.
219    last_system_time_ = system_time;
220    last_cpu_time_ = time;
221    return 0;
222  }
223
224  int64 system_time_delta = system_time - last_system_time_;
225  int64 time_delta = time - last_cpu_time_;
226  DCHECK_NE(0U, time_delta);
227  if (time_delta == 0)
228    return 0;
229
230  // We add time_delta / 2 so the result is rounded.
231  int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
232                             time_delta);
233
234  last_system_time_ = system_time;
235  last_cpu_time_ = time;
236
237  return cpu;
238}
239
240bool ProcessMetrics::CalculateFreeMemory(FreeMBytes* free) const {
241  const SIZE_T kTopAddress = 0x7F000000;
242  const SIZE_T kMegabyte = 1024 * 1024;
243  SIZE_T accumulated = 0;
244
245  MEMORY_BASIC_INFORMATION largest = {0};
246  UINT_PTR scan = 0;
247  while (scan < kTopAddress) {
248    MEMORY_BASIC_INFORMATION info;
249    if (!::VirtualQueryEx(process_, reinterpret_cast<void*>(scan),
250                          &info, sizeof(info)))
251      return false;
252    if (info.State == MEM_FREE) {
253      accumulated += info.RegionSize;
254      if (info.RegionSize > largest.RegionSize)
255        largest = info;
256    }
257    scan += info.RegionSize;
258  }
259  free->largest = largest.RegionSize / kMegabyte;
260  free->largest_ptr = largest.BaseAddress;
261  free->total = accumulated / kMegabyte;
262  return true;
263}
264
265bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
266  return GetProcessIoCounters(process_, io_counters) != FALSE;
267}
268
269ProcessMetrics::ProcessMetrics(ProcessHandle process)
270    : process_(process),
271      processor_count_(base::SysInfo::NumberOfProcessors()),
272      last_cpu_time_(0),
273      last_system_time_(0) {
274}
275
276// GetPerformanceInfo is not available on WIN2K.  So we'll
277// load it on-the-fly.
278const wchar_t kPsapiDllName[] = L"psapi.dll";
279typedef BOOL (WINAPI *GetPerformanceInfoFunction) (
280    PPERFORMANCE_INFORMATION pPerformanceInformation,
281    DWORD cb);
282
283// Beware of races if called concurrently from multiple threads.
284static BOOL InternalGetPerformanceInfo(
285    PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb) {
286  static GetPerformanceInfoFunction GetPerformanceInfo_func = NULL;
287  if (!GetPerformanceInfo_func) {
288    HMODULE psapi_dll = ::GetModuleHandle(kPsapiDllName);
289    if (psapi_dll)
290      GetPerformanceInfo_func = reinterpret_cast<GetPerformanceInfoFunction>(
291          GetProcAddress(psapi_dll, "GetPerformanceInfo"));
292
293    if (!GetPerformanceInfo_func) {
294      // The function could be loaded!
295      memset(pPerformanceInformation, 0, cb);
296      return FALSE;
297    }
298  }
299  return GetPerformanceInfo_func(pPerformanceInformation, cb);
300}
301
302size_t GetSystemCommitCharge() {
303  // Get the System Page Size.
304  SYSTEM_INFO system_info;
305  GetSystemInfo(&system_info);
306
307  PERFORMANCE_INFORMATION info;
308  if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
309    DLOG(ERROR) << "Failed to fetch internal performance info.";
310    return 0;
311  }
312  return (info.CommitTotal * system_info.dwPageSize) / 1024;
313}
314
315}  // namespace base
316