| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "chrome/test/perf/perf_test.h" | |
| 6 | |
| 7 #include <stdio.h> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/process/process.h" | |
| 11 #include "base/strings/string_number_conversions.h" | |
| 12 #include "base/strings/stringprintf.h" | |
| 13 #include "chrome/test/base/chrome_process_util.h" | |
| 14 #include "testing/perf/perf_test.h" | |
| 15 | |
| 16 namespace perf_test { | |
| 17 | |
| 18 void PrintIOPerfInfo(const std::string& test_name, | |
| 19 const ChromeProcessList& chrome_processes, | |
| 20 base::ProcessId browser_pid) { | |
| 21 PrintIOPerfInfo(stdout, test_name, chrome_processes, browser_pid); | |
| 22 } | |
| 23 | |
| 24 void PrintIOPerfInfo(FILE* target, | |
| 25 const std::string& test_name, | |
| 26 const ChromeProcessList& chrome_processes, | |
| 27 base::ProcessId browser_pid) { | |
| 28 fprintf(target, "%s", IOPerfInfoToString(test_name, chrome_processes, | |
| 29 browser_pid).c_str()); | |
| 30 } | |
| 31 | |
| 32 std::string IOPerfInfoToString(const std::string& test_name, | |
| 33 const ChromeProcessList& chrome_processes, | |
| 34 base::ProcessId browser_pid) { | |
| 35 size_t read_op_b = 0; | |
| 36 size_t read_op_r = 0; | |
| 37 size_t write_op_b = 0; | |
| 38 size_t write_op_r = 0; | |
| 39 size_t other_op_b = 0; | |
| 40 size_t other_op_r = 0; | |
| 41 size_t total_op_b = 0; | |
| 42 size_t total_op_r = 0; | |
| 43 | |
| 44 size_t read_byte_b = 0; | |
| 45 size_t read_byte_r = 0; | |
| 46 size_t write_byte_b = 0; | |
| 47 size_t write_byte_r = 0; | |
| 48 size_t other_byte_b = 0; | |
| 49 size_t other_byte_r = 0; | |
| 50 size_t total_byte_b = 0; | |
| 51 size_t total_byte_r = 0; | |
| 52 | |
| 53 std::string output; | |
| 54 ChromeProcessList::const_iterator it; | |
| 55 for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) { | |
| 56 base::Process process = base::Process::Open(*it); | |
| 57 if (!process.IsValid()) { | |
| 58 NOTREACHED(); | |
| 59 return output; | |
| 60 } | |
| 61 | |
| 62 // TODO(sgk): if/when base::ProcessMetrics returns real stats on mac: | |
| 63 // scoped_ptr<base::ProcessMetrics> process_metrics( | |
| 64 // base::ProcessMetrics::CreateProcessMetrics(process.Handle())); | |
| 65 scoped_ptr<ChromeTestProcessMetrics> process_metrics( | |
| 66 ChromeTestProcessMetrics::CreateProcessMetrics(process.Handle())); | |
| 67 base::IoCounters io_counters; | |
| 68 memset(&io_counters, 0, sizeof(io_counters)); | |
| 69 | |
| 70 if (process_metrics.get()->GetIOCounters(&io_counters)) { | |
| 71 // Print out IO performance. We assume that the values can be | |
| 72 // converted to size_t (they're reported as ULONGLONG, 64-bit numbers). | |
| 73 std::string chrome_name = (*it == browser_pid) ? "_b" : "_r"; | |
| 74 | |
| 75 size_t read_op = static_cast<size_t>(io_counters.ReadOperationCount); | |
| 76 size_t write_op = static_cast<size_t>(io_counters.WriteOperationCount); | |
| 77 size_t other_op = static_cast<size_t>(io_counters.OtherOperationCount); | |
| 78 size_t total_op = static_cast<size_t>(io_counters.ReadOperationCount + | |
| 79 io_counters.WriteOperationCount + | |
| 80 io_counters.OtherOperationCount); | |
| 81 | |
| 82 size_t read_byte = static_cast<size_t>(io_counters.ReadTransferCount | |
| 83 / 1024); | |
| 84 size_t write_byte = static_cast<size_t>(io_counters.WriteTransferCount | |
| 85 / 1024); | |
| 86 size_t other_byte = static_cast<size_t>(io_counters.OtherTransferCount | |
| 87 / 1024); | |
| 88 size_t total_byte = static_cast<size_t>((io_counters.ReadTransferCount + | |
| 89 io_counters.WriteTransferCount + | |
| 90 io_counters.OtherTransferCount) | |
| 91 / 1024); | |
| 92 | |
| 93 if (*it == browser_pid) { | |
| 94 read_op_b = read_op; | |
| 95 write_op_b = write_op; | |
| 96 other_op_b = other_op; | |
| 97 total_op_b = total_op; | |
| 98 read_byte_b = read_byte; | |
| 99 write_byte_b = write_byte; | |
| 100 other_byte_b = other_byte; | |
| 101 total_byte_b = total_byte; | |
| 102 } else { | |
| 103 read_op_r += read_op; | |
| 104 write_op_r += write_op; | |
| 105 other_op_r += other_op; | |
| 106 total_op_r += total_op; | |
| 107 read_byte_r += read_byte; | |
| 108 write_byte_r += write_byte; | |
| 109 other_byte_r += other_byte; | |
| 110 total_byte_r += total_byte; | |
| 111 } | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 std::string t_name(test_name); | |
| 116 AppendResult(output, | |
| 117 "read_op_b", | |
| 118 std::string(), | |
| 119 "r_op_b" + t_name, | |
| 120 read_op_b, | |
| 121 "ops", | |
| 122 false); | |
| 123 AppendResult(output, | |
| 124 "write_op_b", | |
| 125 std::string(), | |
| 126 "w_op_b" + t_name, | |
| 127 write_op_b, | |
| 128 "ops", | |
| 129 false); | |
| 130 AppendResult(output, | |
| 131 "other_op_b", | |
| 132 std::string(), | |
| 133 "o_op_b" + t_name, | |
| 134 other_op_b, | |
| 135 "ops", | |
| 136 false); | |
| 137 AppendResult(output, | |
| 138 "total_op_b", | |
| 139 std::string(), | |
| 140 "IO_op_b" + t_name, | |
| 141 total_op_b, | |
| 142 "ops", | |
| 143 false); | |
| 144 | |
| 145 AppendResult(output, | |
| 146 "read_byte_b", | |
| 147 std::string(), | |
| 148 "r_b" + t_name, | |
| 149 read_byte_b, | |
| 150 "kb", | |
| 151 false); | |
| 152 AppendResult(output, | |
| 153 "write_byte_b", | |
| 154 std::string(), | |
| 155 "w_b" + t_name, | |
| 156 write_byte_b, | |
| 157 "kb", | |
| 158 false); | |
| 159 AppendResult(output, | |
| 160 "other_byte_b", | |
| 161 std::string(), | |
| 162 "o_b" + t_name, | |
| 163 other_byte_b, | |
| 164 "kb", | |
| 165 false); | |
| 166 AppendResult(output, | |
| 167 "total_byte_b", | |
| 168 std::string(), | |
| 169 "IO_b" + t_name, | |
| 170 total_byte_b, | |
| 171 "kb", | |
| 172 false); | |
| 173 | |
| 174 AppendResult(output, | |
| 175 "read_op_r", | |
| 176 std::string(), | |
| 177 "r_op_r" + t_name, | |
| 178 read_op_r, | |
| 179 "ops", | |
| 180 false); | |
| 181 AppendResult(output, | |
| 182 "write_op_r", | |
| 183 std::string(), | |
| 184 "w_op_r" + t_name, | |
| 185 write_op_r, | |
| 186 "ops", | |
| 187 false); | |
| 188 AppendResult(output, | |
| 189 "other_op_r", | |
| 190 std::string(), | |
| 191 "o_op_r" + t_name, | |
| 192 other_op_r, | |
| 193 "ops", | |
| 194 false); | |
| 195 AppendResult(output, | |
| 196 "total_op_r", | |
| 197 std::string(), | |
| 198 "IO_op_r" + t_name, | |
| 199 total_op_r, | |
| 200 "ops", | |
| 201 false); | |
| 202 | |
| 203 AppendResult(output, | |
| 204 "read_byte_r", | |
| 205 std::string(), | |
| 206 "r_r" + t_name, | |
| 207 read_byte_r, | |
| 208 "kb", | |
| 209 false); | |
| 210 AppendResult(output, | |
| 211 "write_byte_r", | |
| 212 std::string(), | |
| 213 "w_r" + t_name, | |
| 214 write_byte_r, | |
| 215 "kb", | |
| 216 false); | |
| 217 AppendResult(output, | |
| 218 "other_byte_r", | |
| 219 std::string(), | |
| 220 "o_r" + t_name, | |
| 221 other_byte_r, | |
| 222 "kb", | |
| 223 false); | |
| 224 AppendResult(output, | |
| 225 "total_byte_r", | |
| 226 std::string(), | |
| 227 "IO_r" + t_name, | |
| 228 total_byte_r, | |
| 229 "kb", | |
| 230 false); | |
| 231 | |
| 232 return output; | |
| 233 } | |
| 234 | |
| 235 void PrintMemoryUsageInfo(const std::string& test_name, | |
| 236 const ChromeProcessList& chrome_processes, | |
| 237 base::ProcessId browser_pid) { | |
| 238 PrintMemoryUsageInfo(stdout, test_name, chrome_processes, browser_pid); | |
| 239 } | |
| 240 | |
| 241 void PrintMemoryUsageInfo(FILE* target, | |
| 242 const std::string& test_name, | |
| 243 const ChromeProcessList& chrome_processes, | |
| 244 base::ProcessId browser_pid) { | |
| 245 fprintf(target, "%s", MemoryUsageInfoToString(test_name, chrome_processes, | |
| 246 browser_pid).c_str()); | |
| 247 } | |
| 248 | |
| 249 std::string MemoryUsageInfoToString(const std::string& test_name, | |
| 250 const ChromeProcessList& chrome_processes, | |
| 251 base::ProcessId browser_pid) { | |
| 252 size_t browser_virtual_size = 0; | |
| 253 size_t browser_working_set_size = 0; | |
| 254 size_t renderer_virtual_size = 0; | |
| 255 size_t renderer_working_set_size = 0; | |
| 256 size_t total_virtual_size = 0; | |
| 257 size_t total_working_set_size = 0; | |
| 258 #if defined(OS_WIN) | |
| 259 size_t browser_peak_virtual_size = 0; | |
| 260 size_t browser_peak_working_set_size = 0; | |
| 261 size_t renderer_total_peak_virtual_size = 0; | |
| 262 size_t renderer_total_peak_working_set_size = 0; | |
| 263 size_t renderer_single_peak_virtual_size = 0; | |
| 264 size_t renderer_single_peak_working_set_size = 0; | |
| 265 #endif | |
| 266 | |
| 267 std::string output; | |
| 268 ChromeProcessList::const_iterator it; | |
| 269 for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) { | |
| 270 base::Process process = base::Process::Open(*it); | |
| 271 if (!process.IsValid()) { | |
| 272 NOTREACHED(); | |
| 273 return output; | |
| 274 } | |
| 275 | |
| 276 // TODO(sgk): if/when base::ProcessMetrics returns real stats on mac: | |
| 277 // scoped_ptr<base::ProcessMetrics> process_metrics( | |
| 278 // base::ProcessMetrics::CreateProcessMetrics(process.Handle())); | |
| 279 scoped_ptr<ChromeTestProcessMetrics> process_metrics( | |
| 280 ChromeTestProcessMetrics::CreateProcessMetrics(process.Handle())); | |
| 281 | |
| 282 size_t current_virtual_size = process_metrics->GetPagefileUsage(); | |
| 283 size_t current_working_set_size = process_metrics->GetWorkingSetSize(); | |
| 284 | |
| 285 if (*it == browser_pid) { | |
| 286 browser_virtual_size = current_virtual_size; | |
| 287 browser_working_set_size = current_working_set_size; | |
| 288 } else { | |
| 289 renderer_virtual_size += current_virtual_size; | |
| 290 renderer_working_set_size += current_working_set_size; | |
| 291 } | |
| 292 total_virtual_size += current_virtual_size; | |
| 293 total_working_set_size += current_working_set_size; | |
| 294 | |
| 295 #if defined(OS_WIN) | |
| 296 size_t peak_virtual_size = process_metrics->GetPeakPagefileUsage(); | |
| 297 size_t peak_working_set_size = process_metrics->GetPeakWorkingSetSize(); | |
| 298 if (*it == browser_pid) { | |
| 299 browser_peak_virtual_size = peak_virtual_size; | |
| 300 browser_peak_working_set_size = peak_working_set_size; | |
| 301 } else { | |
| 302 if (peak_virtual_size > renderer_single_peak_virtual_size) { | |
| 303 renderer_single_peak_virtual_size = peak_virtual_size; | |
| 304 } | |
| 305 if (peak_working_set_size > renderer_single_peak_working_set_size) { | |
| 306 renderer_single_peak_working_set_size = peak_working_set_size; | |
| 307 } | |
| 308 renderer_total_peak_virtual_size += peak_virtual_size; | |
| 309 renderer_total_peak_working_set_size += peak_working_set_size; | |
| 310 } | |
| 311 #endif | |
| 312 } | |
| 313 | |
| 314 std::string trace_name(test_name); | |
| 315 #if defined(OS_WIN) | |
| 316 AppendResult(output, "vm_peak_b", "", "vm_pk_b" + trace_name, | |
| 317 browser_peak_virtual_size, "bytes", | |
| 318 false /* not important */); | |
| 319 AppendResult(output, "ws_peak_b", "", "ws_pk_b" + trace_name, | |
| 320 browser_peak_working_set_size, "bytes", | |
| 321 false /* not important */); | |
| 322 AppendResult(output, "vm_peak_r", "", "vm_pk_r" + trace_name, | |
| 323 renderer_total_peak_virtual_size, "bytes", | |
| 324 false /* not important */); | |
| 325 AppendResult(output, "ws_peak_r", "", "ws_pk_r" + trace_name, | |
| 326 renderer_total_peak_working_set_size, "bytes", | |
| 327 false /* not important */); | |
| 328 AppendResult(output, "vm_single_peak_r", "", "vm_spk_r" + trace_name, | |
| 329 renderer_single_peak_virtual_size, "bytes", | |
| 330 false /* not important */); | |
| 331 AppendResult(output, "ws_single_peak_r", "", "ws_spk_r" + trace_name, | |
| 332 renderer_single_peak_working_set_size, "bytes", | |
| 333 false /* important */); | |
| 334 AppendResult(output, "vm_final_b", "", "vm_f_b" + trace_name, | |
| 335 browser_virtual_size, "bytes", | |
| 336 false /* not important */); | |
| 337 AppendResult(output, "ws_final_b", "", "ws_f_b" + trace_name, | |
| 338 browser_working_set_size, "bytes", | |
| 339 false /* not important */); | |
| 340 AppendResult(output, "vm_final_r", "", "vm_f_r" + trace_name, | |
| 341 renderer_virtual_size, "bytes", | |
| 342 false /* not important */); | |
| 343 AppendResult(output, "ws_final_r", "", "ws_f_r" + trace_name, | |
| 344 renderer_working_set_size, "bytes", | |
| 345 false /* not important */); | |
| 346 AppendResult(output, "vm_final_t", "", "vm_f_t" + trace_name, | |
| 347 total_virtual_size, "bytes", | |
| 348 false /* not important */); | |
| 349 AppendResult(output, "ws_final_t", "", "ws_f_t" + trace_name, | |
| 350 total_working_set_size, "bytes", | |
| 351 false /* not important */); | |
| 352 #elif defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_ANDROID) | |
| 353 AppendResult(output, | |
| 354 "vm_size_final_b", | |
| 355 std::string(), | |
| 356 "vm_size_f_b" + trace_name, | |
| 357 browser_virtual_size, | |
| 358 "bytes", | |
| 359 false /* not important */); | |
| 360 AppendResult(output, | |
| 361 "vm_rss_final_b", | |
| 362 std::string(), | |
| 363 "vm_rss_f_b" + trace_name, | |
| 364 browser_working_set_size, | |
| 365 "bytes", | |
| 366 false /* not important */); | |
| 367 AppendResult(output, | |
| 368 "vm_size_final_r", | |
| 369 std::string(), | |
| 370 "vm_size_f_r" + trace_name, | |
| 371 renderer_virtual_size, | |
| 372 "bytes", | |
| 373 false /* not important */); | |
| 374 AppendResult(output, | |
| 375 "vm_rss_final_r", | |
| 376 std::string(), | |
| 377 "vm_rss_f_r" + trace_name, | |
| 378 renderer_working_set_size, | |
| 379 "bytes", | |
| 380 false /* not important */); | |
| 381 AppendResult(output, | |
| 382 "vm_size_final_t", | |
| 383 std::string(), | |
| 384 "vm_size_f_t" + trace_name, | |
| 385 total_virtual_size, | |
| 386 "bytes", | |
| 387 false /* not important */); | |
| 388 AppendResult(output, | |
| 389 "vm_rss_final_t", | |
| 390 std::string(), | |
| 391 "vm_rss_f_t" + trace_name, | |
| 392 total_working_set_size, | |
| 393 "bytes", | |
| 394 false /* not important */); | |
| 395 #else | |
| 396 NOTIMPLEMENTED(); | |
| 397 #endif | |
| 398 AppendResult(output, | |
| 399 "processes", | |
| 400 std::string(), | |
| 401 "proc_" + trace_name, | |
| 402 chrome_processes.size(), | |
| 403 "count", | |
| 404 false /* not important */); | |
| 405 | |
| 406 return output; | |
| 407 } | |
| 408 | |
| 409 } // namespace perf_test | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 938603004:
Cleanup: Remove chrome_perf_test target. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master