1 /* 2 * builtin-stat.c 3 * 4 * Builtin stat command: Give a precise performance counters summary 5 * overview about any workload, CPU or specific PID. 6 * 7 * Sample output: 8 9 $ perf stat ~/hackbench 10 10 Time: 0.104 11 12 Performance counter stats for '/home/mingo/hackbench': 13 14 1255.538611 task clock ticks # 10.143 CPU utilization factor 15 54011 context switches # 0.043 M/sec 16 385 CPU migrations # 0.000 M/sec 17 17755 pagefaults # 0.014 M/sec 18 3808323185 CPU cycles # 3033.219 M/sec 19 1575111190 instructions # 1254.530 M/sec 20 17367895 cache references # 13.833 M/sec 21 7674421 cache misses # 6.112 M/sec 22 23 Wall-clock time elapsed: 123.786620 msecs 24 25 * 26 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 27 * 28 * Improvements and fixes by: 29 * 30 * Arjan van de Ven <arjan@linux.intel.com> 31 * Yanmin Zhang <yanmin.zhang@intel.com> 32 * Wu Fengguang <fengguang.wu@intel.com> 33 * Mike Galbraith <efault@gmx.de> 34 * Paul Mackerras <paulus@samba.org> 35 * Jaswinder Singh Rajput <jaswinder@kernel.org> 36 * 37 * Released under the GPL v2. (and only v2, not any later version) 38 */ 39 40 #include "perf.h" 41 #include "builtin.h" 42 #include "util/util.h" 43 #include "util/parse-options.h" 44 #include "util/parse-events.h" 45 #include "util/event.h" 46 #include "util/evsel.h" 47 #include "util/debug.h" 48 #include "util/header.h" 49 #include "util/cpumap.h" 50 #include "util/thread.h" 51 52 #include <sys/prctl.h> 53 #include <math.h> 54 #include <locale.h> 55 56 #define DEFAULT_SEPARATOR " " 57 58 static struct perf_event_attr default_attrs[] = { 59 60 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 61 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 62 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 63 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 64 65 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 66 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 67 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 68 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 69 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES }, 70 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES }, 71 72 }; 73 74 static bool system_wide = false; 75 static struct cpu_map *cpus; 76 static int run_idx = 0; 77 78 static int run_count = 1; 79 static bool no_inherit = false; 80 static bool scale = true; 81 static bool no_aggr = false; 82 static pid_t target_pid = -1; 83 static pid_t target_tid = -1; 84 static struct thread_map *threads; 85 static pid_t child_pid = -1; 86 static bool null_run = false; 87 static bool big_num = true; 88 static int big_num_opt = -1; 89 static const char *cpu_list; 90 static const char *csv_sep = NULL; 91 static bool csv_output = false; 92 93 static volatile int done = 0; 94 95 struct stats 96 { 97 double n, mean, M2; 98 }; 99 100 struct perf_stat { 101 struct stats res_stats[3]; 102 }; 103 104 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel) 105 { 106 evsel->priv = zalloc(sizeof(struct perf_stat)); 107 return evsel->priv == NULL ? -ENOMEM : 0; 108 } 109 110 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel) 111 { 112 free(evsel->priv); 113 evsel->priv = NULL; 114 } 115 116 static void update_stats(struct stats *stats, u64 val) 117 { 118 double delta; 119 120 stats->n++; 121 delta = val - stats->mean; 122 stats->mean += delta / stats->n; 123 stats->M2 += delta*(val - stats->mean); 124 } 125 126 static double avg_stats(struct stats *stats) 127 { 128 return stats->mean; 129 } 130 131 /* 132 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance 133 * 134 * (\Sum n_i^2) - ((\Sum n_i)^2)/n 135 * s^2 = ------------------------------- 136 * n - 1 137 * 138 * http://en.wikipedia.org/wiki/Stddev 139 * 140 * The std dev of the mean is related to the std dev by: 141 * 142 * s 143 * s_mean = ------- 144 * sqrt(n) 145 * 146 */ 147 static double stddev_stats(struct stats *stats) 148 { 149 double variance = stats->M2 / (stats->n - 1); 150 double variance_mean = variance / stats->n; 151 152 return sqrt(variance_mean); 153 } 154 155 struct stats runtime_nsecs_stats[MAX_NR_CPUS]; 156 struct stats runtime_cycles_stats[MAX_NR_CPUS]; 157 struct stats runtime_branches_stats[MAX_NR_CPUS]; 158 struct stats walltime_nsecs_stats; 159 160 static int create_perf_stat_counter(struct perf_evsel *evsel) 161 { 162 struct perf_event_attr *attr = &evsel->attr; 163 164 if (scale) 165 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | 166 PERF_FORMAT_TOTAL_TIME_RUNNING; 167 168 if (system_wide) 169 return perf_evsel__open_per_cpu(evsel, cpus); 170 171 attr->inherit = !no_inherit; 172 if (target_pid == -1 && target_tid == -1) { 173 attr->disabled = 1; 174 attr->enable_on_exec = 1; 175 } 176 177 return perf_evsel__open_per_thread(evsel, threads); 178 } 179 180 /* 181 * Does the counter have nsecs as a unit? 182 */ 183 static inline int nsec_counter(struct perf_evsel *evsel) 184 { 185 if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) || 186 perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 187 return 1; 188 189 return 0; 190 } 191 192 /* 193 * Read out the results of a single counter: 194 * aggregate counts across CPUs in system-wide mode 195 */ 196 static int read_counter_aggr(struct perf_evsel *counter) 197 { 198 struct perf_stat *ps = counter->priv; 199 u64 *count = counter->counts->aggr.values; 200 int i; 201 202 if (__perf_evsel__read(counter, cpus->nr, threads->nr, scale) < 0) 203 return -1; 204 205 for (i = 0; i < 3; i++) 206 update_stats(&ps->res_stats[i], count[i]); 207 208 if (verbose) { 209 fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter), 210 count[0], count[1], count[2]); 211 } 212 213 /* 214 * Save the full runtime - to allow normalization during printout: 215 */ 216 if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK)) 217 update_stats(&runtime_nsecs_stats[0], count[0]); 218 if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES)) 219 update_stats(&runtime_cycles_stats[0], count[0]); 220 if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS)) 221 update_stats(&runtime_branches_stats[0], count[0]); 222 223 return 0; 224 } 225 226 /* 227 * Read out the results of a single counter: 228 * do not aggregate counts across CPUs in system-wide mode 229 */ 230 static int read_counter(struct perf_evsel *counter) 231 { 232 u64 *count; 233 int cpu; 234 235 for (cpu = 0; cpu < cpus->nr; cpu++) { 236 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0) 237 return -1; 238 239 count = counter->counts->cpu[cpu].values; 240 241 if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK)) 242 update_stats(&runtime_nsecs_stats[cpu], count[0]); 243 if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES)) 244 update_stats(&runtime_cycles_stats[cpu], count[0]); 245 if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS)) 246 update_stats(&runtime_branches_stats[cpu], count[0]); 247 } 248 249 return 0; 250 } 251 252 static int run_perf_stat(int argc __used, const char **argv) 253 { 254 unsigned long long t0, t1; 255 struct perf_evsel *counter; 256 int status = 0; 257 int child_ready_pipe[2], go_pipe[2]; 258 const bool forks = (argc > 0); 259 char buf; 260 261 if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) { 262 perror("failed to create pipes"); 263 exit(1); 264 } 265 266 if (forks) { 267 if ((child_pid = fork()) < 0) 268 perror("failed to fork"); 269 270 if (!child_pid) { 271 close(child_ready_pipe[0]); 272 close(go_pipe[1]); 273 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC); 274 275 /* 276 * Do a dummy execvp to get the PLT entry resolved, 277 * so we avoid the resolver overhead on the real 278 * execvp call. 279 */ 280 execvp("", (char **)argv); 281 282 /* 283 * Tell the parent we're ready to go 284 */ 285 close(child_ready_pipe[1]); 286 287 /* 288 * Wait until the parent tells us to go. 289 */ 290 if (read(go_pipe[0], &buf, 1) == -1) 291 perror("unable to read pipe"); 292 293 execvp(argv[0], (char **)argv); 294 295 perror(argv[0]); 296 exit(-1); 297 } 298 299 if (target_tid == -1 && target_pid == -1 && !system_wide) 300 threads->map[0] = child_pid; 301 302 /* 303 * Wait for the child to be ready to exec. 304 */ 305 close(child_ready_pipe[1]); 306 close(go_pipe[0]); 307 if (read(child_ready_pipe[0], &buf, 1) == -1) 308 perror("unable to read pipe"); 309 close(child_ready_pipe[0]); 310 } 311 312 list_for_each_entry(counter, &evsel_list, node) { 313 if (create_perf_stat_counter(counter) < 0) { 314 if (errno == -EPERM || errno == -EACCES) { 315 error("You may not have permission to collect %sstats.\n" 316 "\t Consider tweaking" 317 " /proc/sys/kernel/perf_event_paranoid or running as root.", 318 system_wide ? "system-wide " : ""); 319 } else { 320 error("open_counter returned with %d (%s). " 321 "/bin/dmesg may provide additional information.\n", 322 errno, strerror(errno)); 323 } 324 if (child_pid != -1) 325 kill(child_pid, SIGTERM); 326 die("Not all events could be opened.\n"); 327 return -1; 328 } 329 } 330 331 /* 332 * Enable counters and exec the command: 333 */ 334 t0 = rdclock(); 335 336 if (forks) { 337 close(go_pipe[1]); 338 wait(&status); 339 } else { 340 while(!done) sleep(1); 341 } 342 343 t1 = rdclock(); 344 345 update_stats(&walltime_nsecs_stats, t1 - t0); 346 347 if (no_aggr) { 348 list_for_each_entry(counter, &evsel_list, node) { 349 read_counter(counter); 350 perf_evsel__close_fd(counter, cpus->nr, 1); 351 } 352 } else { 353 list_for_each_entry(counter, &evsel_list, node) { 354 read_counter_aggr(counter); 355 perf_evsel__close_fd(counter, cpus->nr, threads->nr); 356 } 357 } 358 359 return WEXITSTATUS(status); 360 } 361 362 static void print_noise(struct perf_evsel *evsel, double avg) 363 { 364 struct perf_stat *ps; 365 366 if (run_count == 1) 367 return; 368 369 ps = evsel->priv; 370 fprintf(stderr, " ( +- %7.3f%% )", 371 100 * stddev_stats(&ps->res_stats[0]) / avg); 372 } 373 374 static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg) 375 { 376 double msecs = avg / 1e6; 377 char cpustr[16] = { '\0', }; 378 const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-24s"; 379 380 if (no_aggr) 381 sprintf(cpustr, "CPU%*d%s", 382 csv_output ? 0 : -4, 383 cpus->map[cpu], csv_sep); 384 385 fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel)); 386 387 if (csv_output) 388 return; 389 390 if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 391 fprintf(stderr, " # %10.3f CPUs ", 392 avg / avg_stats(&walltime_nsecs_stats)); 393 } 394 395 static void abs_printout(int cpu, struct perf_evsel *evsel, double avg) 396 { 397 double total, ratio = 0.0; 398 char cpustr[16] = { '\0', }; 399 const char *fmt; 400 401 if (csv_output) 402 fmt = "%s%.0f%s%s"; 403 else if (big_num) 404 fmt = "%s%'18.0f%s%-24s"; 405 else 406 fmt = "%s%18.0f%s%-24s"; 407 408 if (no_aggr) 409 sprintf(cpustr, "CPU%*d%s", 410 csv_output ? 0 : -4, 411 cpus->map[cpu], csv_sep); 412 else 413 cpu = 0; 414 415 fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel)); 416 417 if (csv_output) 418 return; 419 420 if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { 421 total = avg_stats(&runtime_cycles_stats[cpu]); 422 423 if (total) 424 ratio = avg / total; 425 426 fprintf(stderr, " # %10.3f IPC ", ratio); 427 } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) && 428 runtime_branches_stats[cpu].n != 0) { 429 total = avg_stats(&runtime_branches_stats[cpu]); 430 431 if (total) 432 ratio = avg * 100 / total; 433 434 fprintf(stderr, " # %10.3f %% ", ratio); 435 436 } else if (runtime_nsecs_stats[cpu].n != 0) { 437 total = avg_stats(&runtime_nsecs_stats[cpu]); 438 439 if (total) 440 ratio = 1000.0 * avg / total; 441 442 fprintf(stderr, " # %10.3f M/sec", ratio); 443 } 444 } 445 446 /* 447 * Print out the results of a single counter: 448 * aggregated counts in system-wide mode 449 */ 450 static void print_counter_aggr(struct perf_evsel *counter) 451 { 452 struct perf_stat *ps = counter->priv; 453 double avg = avg_stats(&ps->res_stats[0]); 454 int scaled = counter->counts->scaled; 455 456 if (scaled == -1) { 457 fprintf(stderr, "%*s%s%-24s\n", 458 csv_output ? 0 : 18, 459 "<not counted>", csv_sep, event_name(counter)); 460 return; 461 } 462 463 if (nsec_counter(counter)) 464 nsec_printout(-1, counter, avg); 465 else 466 abs_printout(-1, counter, avg); 467 468 if (csv_output) { 469 fputc('\n', stderr); 470 return; 471 } 472 473 print_noise(counter, avg); 474 475 if (scaled) { 476 double avg_enabled, avg_running; 477 478 avg_enabled = avg_stats(&ps->res_stats[1]); 479 avg_running = avg_stats(&ps->res_stats[2]); 480 481 fprintf(stderr, " (scaled from %.2f%%)", 482 100 * avg_running / avg_enabled); 483 } 484 485 fprintf(stderr, "\n"); 486 } 487 488 /* 489 * Print out the results of a single counter: 490 * does not use aggregated count in system-wide 491 */ 492 static void print_counter(struct perf_evsel *counter) 493 { 494 u64 ena, run, val; 495 int cpu; 496 497 for (cpu = 0; cpu < cpus->nr; cpu++) { 498 val = counter->counts->cpu[cpu].val; 499 ena = counter->counts->cpu[cpu].ena; 500 run = counter->counts->cpu[cpu].run; 501 if (run == 0 || ena == 0) { 502 fprintf(stderr, "CPU%*d%s%*s%s%-24s", 503 csv_output ? 0 : -4, 504 cpus->map[cpu], csv_sep, 505 csv_output ? 0 : 18, 506 "<not counted>", csv_sep, 507 event_name(counter)); 508 509 fprintf(stderr, "\n"); 510 continue; 511 } 512 513 if (nsec_counter(counter)) 514 nsec_printout(cpu, counter, val); 515 else 516 abs_printout(cpu, counter, val); 517 518 if (!csv_output) { 519 print_noise(counter, 1.0); 520 521 if (run != ena) { 522 fprintf(stderr, " (scaled from %.2f%%)", 523 100.0 * run / ena); 524 } 525 } 526 fprintf(stderr, "\n"); 527 } 528 } 529 530 static void print_stat(int argc, const char **argv) 531 { 532 struct perf_evsel *counter; 533 int i; 534 535 fflush(stdout); 536 537 if (!csv_output) { 538 fprintf(stderr, "\n"); 539 fprintf(stderr, " Performance counter stats for "); 540 if(target_pid == -1 && target_tid == -1) { 541 fprintf(stderr, "\'%s", argv[0]); 542 for (i = 1; i < argc; i++) 543 fprintf(stderr, " %s", argv[i]); 544 } else if (target_pid != -1) 545 fprintf(stderr, "process id \'%d", target_pid); 546 else 547 fprintf(stderr, "thread id \'%d", target_tid); 548 549 fprintf(stderr, "\'"); 550 if (run_count > 1) 551 fprintf(stderr, " (%d runs)", run_count); 552 fprintf(stderr, ":\n\n"); 553 } 554 555 if (no_aggr) { 556 list_for_each_entry(counter, &evsel_list, node) 557 print_counter(counter); 558 } else { 559 list_for_each_entry(counter, &evsel_list, node) 560 print_counter_aggr(counter); 561 } 562 563 if (!csv_output) { 564 fprintf(stderr, "\n"); 565 fprintf(stderr, " %18.9f seconds time elapsed", 566 avg_stats(&walltime_nsecs_stats)/1e9); 567 if (run_count > 1) { 568 fprintf(stderr, " ( +- %7.3f%% )", 569 100*stddev_stats(&walltime_nsecs_stats) / 570 avg_stats(&walltime_nsecs_stats)); 571 } 572 fprintf(stderr, "\n\n"); 573 } 574 } 575 576 static volatile int signr = -1; 577 578 static void skip_signal(int signo) 579 { 580 if(child_pid == -1) 581 done = 1; 582 583 signr = signo; 584 } 585 586 static void sig_atexit(void) 587 { 588 if (child_pid != -1) 589 kill(child_pid, SIGTERM); 590 591 if (signr == -1) 592 return; 593 594 signal(signr, SIG_DFL); 595 kill(getpid(), signr); 596 } 597 598 static const char * const stat_usage[] = { 599 "perf stat [<options>] [<command>]", 600 NULL 601 }; 602 603 static int stat__set_big_num(const struct option *opt __used, 604 const char *s __used, int unset) 605 { 606 big_num_opt = unset ? 0 : 1; 607 return 0; 608 } 609 610 static const struct option options[] = { 611 OPT_CALLBACK('e', "event", NULL, "event", 612 "event selector. use 'perf list' to list available events", 613 parse_events), 614 OPT_BOOLEAN('i', "no-inherit", &no_inherit, 615 "child tasks do not inherit counters"), 616 OPT_INTEGER('p', "pid", &target_pid, 617 "stat events on existing process id"), 618 OPT_INTEGER('t', "tid", &target_tid, 619 "stat events on existing thread id"), 620 OPT_BOOLEAN('a', "all-cpus", &system_wide, 621 "system-wide collection from all CPUs"), 622 OPT_BOOLEAN('c', "scale", &scale, 623 "scale/normalize counters"), 624 OPT_INCR('v', "verbose", &verbose, 625 "be more verbose (show counter open errors, etc)"), 626 OPT_INTEGER('r', "repeat", &run_count, 627 "repeat command and print average + stddev (max: 100)"), 628 OPT_BOOLEAN('n', "null", &null_run, 629 "null run - dont start any counters"), 630 OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 631 "print large numbers with thousands\' separators", 632 stat__set_big_num), 633 OPT_STRING('C', "cpu", &cpu_list, "cpu", 634 "list of cpus to monitor in system-wide"), 635 OPT_BOOLEAN('A', "no-aggr", &no_aggr, 636 "disable CPU count aggregation"), 637 OPT_STRING('x', "field-separator", &csv_sep, "separator", 638 "print counts with custom separator"), 639 OPT_END() 640 }; 641 642 int cmd_stat(int argc, const char **argv, const char *prefix __used) 643 { 644 struct perf_evsel *pos; 645 int status = -ENOMEM; 646 647 setlocale(LC_ALL, ""); 648 649 argc = parse_options(argc, argv, options, stat_usage, 650 PARSE_OPT_STOP_AT_NON_OPTION); 651 652 if (csv_sep) 653 csv_output = true; 654 else 655 csv_sep = DEFAULT_SEPARATOR; 656 657 /* 658 * let the spreadsheet do the pretty-printing 659 */ 660 if (csv_output) { 661 /* User explicitely passed -B? */ 662 if (big_num_opt == 1) { 663 fprintf(stderr, "-B option not supported with -x\n"); 664 usage_with_options(stat_usage, options); 665 } else /* Nope, so disable big number formatting */ 666 big_num = false; 667 } else if (big_num_opt == 0) /* User passed --no-big-num */ 668 big_num = false; 669 670 if (!argc && target_pid == -1 && target_tid == -1) 671 usage_with_options(stat_usage, options); 672 if (run_count <= 0) 673 usage_with_options(stat_usage, options); 674 675 /* no_aggr is for system-wide only */ 676 if (no_aggr && !system_wide) 677 usage_with_options(stat_usage, options); 678 679 /* Set attrs and nr_counters if no event is selected and !null_run */ 680 if (!null_run && !nr_counters) { 681 size_t c; 682 683 nr_counters = ARRAY_SIZE(default_attrs); 684 685 for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) { 686 pos = perf_evsel__new(default_attrs[c].type, 687 default_attrs[c].config, 688 nr_counters); 689 if (pos == NULL) 690 goto out; 691 list_add(&pos->node, &evsel_list); 692 } 693 } 694 695 if (target_pid != -1) 696 target_tid = target_pid; 697 698 threads = thread_map__new(target_pid, target_tid); 699 if (threads == NULL) { 700 pr_err("Problems finding threads of monitor\n"); 701 usage_with_options(stat_usage, options); 702 } 703 704 if (system_wide) 705 cpus = cpu_map__new(cpu_list); 706 else 707 cpus = cpu_map__dummy_new(); 708 709 if (cpus == NULL) { 710 perror("failed to parse CPUs map"); 711 usage_with_options(stat_usage, options); 712 return -1; 713 } 714 715 list_for_each_entry(pos, &evsel_list, node) { 716 if (perf_evsel__alloc_stat_priv(pos) < 0 || 717 perf_evsel__alloc_counts(pos, cpus->nr) < 0 || 718 perf_evsel__alloc_fd(pos, cpus->nr, threads->nr) < 0) 719 goto out_free_fd; 720 } 721 722 /* 723 * We dont want to block the signals - that would cause 724 * child tasks to inherit that and Ctrl-C would not work. 725 * What we want is for Ctrl-C to work in the exec()-ed 726 * task, but being ignored by perf stat itself: 727 */ 728 atexit(sig_atexit); 729 signal(SIGINT, skip_signal); 730 signal(SIGALRM, skip_signal); 731 signal(SIGABRT, skip_signal); 732 733 status = 0; 734 for (run_idx = 0; run_idx < run_count; run_idx++) { 735 if (run_count != 1 && verbose) 736 fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1); 737 status = run_perf_stat(argc, argv); 738 } 739 740 if (status != -1) 741 print_stat(argc, argv); 742 out_free_fd: 743 list_for_each_entry(pos, &evsel_list, node) 744 perf_evsel__free_stat_priv(pos); 745 out: 746 thread_map__delete(threads); 747 threads = NULL; 748 return status; 749 } 750