chrome/test/perf/perf_test.cc

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