1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * builtin-stat.c 4 * 5 * Builtin stat command: Give a precise performance counters summary 6 * overview about any workload, CPU or specific PID. 7 * 8 * Sample output: 9 10 $ perf stat ./hackbench 10 11 12 Time: 0.118 13 14 Performance counter stats for './hackbench 10': 15 16 1708.761321 task-clock # 11.037 CPUs utilized 17 41,190 context-switches # 0.024 M/sec 18 6,735 CPU-migrations # 0.004 M/sec 19 17,318 page-faults # 0.010 M/sec 20 5,205,202,243 cycles # 3.046 GHz 21 3,856,436,920 stalled-cycles-frontend # 74.09% frontend cycles idle 22 1,600,790,871 stalled-cycles-backend # 30.75% backend cycles idle 23 2,603,501,247 instructions # 0.50 insns per cycle 24 # 1.48 stalled cycles per insn 25 484,357,498 branches # 283.455 M/sec 26 6,388,934 branch-misses # 1.32% of all branches 27 28 0.154822978 seconds time elapsed 29 30 * 31 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 32 * 33 * Improvements and fixes by: 34 * 35 * Arjan van de Ven <arjan@linux.intel.com> 36 * Yanmin Zhang <yanmin.zhang@intel.com> 37 * Wu Fengguang <fengguang.wu@intel.com> 38 * Mike Galbraith <efault@gmx.de> 39 * Paul Mackerras <paulus@samba.org> 40 * Jaswinder Singh Rajput <jaswinder@kernel.org> 41 */ 42 43 #include "builtin.h" 44 #include "perf.h" 45 #include "util/cgroup.h" 46 #include <subcmd/parse-options.h> 47 #include "util/parse-events.h" 48 #include "util/pmu.h" 49 #include "util/event.h" 50 #include "util/evlist.h" 51 #include "util/evsel.h" 52 #include "util/debug.h" 53 #include "util/color.h" 54 #include "util/stat.h" 55 #include "util/header.h" 56 #include "util/cpumap.h" 57 #include "util/thread_map.h" 58 #include "util/counts.h" 59 #include "util/group.h" 60 #include "util/session.h" 61 #include "util/tool.h" 62 #include "util/string2.h" 63 #include "util/metricgroup.h" 64 #include "util/synthetic-events.h" 65 #include "util/target.h" 66 #include "util/time-utils.h" 67 #include "util/top.h" 68 #include "asm/bug.h" 69 70 #include <linux/time64.h> 71 #include <linux/zalloc.h> 72 #include <api/fs/fs.h> 73 #include <errno.h> 74 #include <signal.h> 75 #include <stdlib.h> 76 #include <sys/prctl.h> 77 #include <inttypes.h> 78 #include <locale.h> 79 #include <math.h> 80 #include <sys/types.h> 81 #include <sys/stat.h> 82 #include <sys/wait.h> 83 #include <unistd.h> 84 #include <sys/time.h> 85 #include <sys/resource.h> 86 #include <linux/err.h> 87 88 #include <linux/ctype.h> 89 #include <perf/evlist.h> 90 91 #define DEFAULT_SEPARATOR " " 92 #define FREEZE_ON_SMI_PATH "devices/cpu/freeze_on_smi" 93 94 static void print_counters(struct timespec *ts, int argc, const char **argv); 95 96 /* Default events used for perf stat -T */ 97 static const char *transaction_attrs = { 98 "task-clock," 99 "{" 100 "instructions," 101 "cycles," 102 "cpu/cycles-t/," 103 "cpu/tx-start/," 104 "cpu/el-start/," 105 "cpu/cycles-ct/" 106 "}" 107 }; 108 109 /* More limited version when the CPU does not have all events. */ 110 static const char * transaction_limited_attrs = { 111 "task-clock," 112 "{" 113 "instructions," 114 "cycles," 115 "cpu/cycles-t/," 116 "cpu/tx-start/" 117 "}" 118 }; 119 120 static const char * topdown_attrs[] = { 121 "topdown-total-slots", 122 "topdown-slots-retired", 123 "topdown-recovery-bubbles", 124 "topdown-fetch-bubbles", 125 "topdown-slots-issued", 126 NULL, 127 }; 128 129 static const char *smi_cost_attrs = { 130 "{" 131 "msr/aperf/," 132 "msr/smi/," 133 "cycles" 134 "}" 135 }; 136 137 static struct evlist *evsel_list; 138 139 static struct target target = { 140 .uid = UINT_MAX, 141 }; 142 143 #define METRIC_ONLY_LEN 20 144 145 static volatile pid_t child_pid = -1; 146 static int detailed_run = 0; 147 static bool transaction_run; 148 static bool topdown_run = false; 149 static bool smi_cost = false; 150 static bool smi_reset = false; 151 static int big_num_opt = -1; 152 static bool group = false; 153 static const char *pre_cmd = NULL; 154 static const char *post_cmd = NULL; 155 static bool sync_run = false; 156 static bool forever = false; 157 static bool force_metric_only = false; 158 static struct timespec ref_time; 159 static bool append_file; 160 static bool interval_count; 161 static const char *output_name; 162 static int output_fd; 163 164 struct perf_stat { 165 bool record; 166 struct perf_data data; 167 struct perf_session *session; 168 u64 bytes_written; 169 struct perf_tool tool; 170 bool maps_allocated; 171 struct perf_cpu_map *cpus; 172 struct perf_thread_map *threads; 173 enum aggr_mode aggr_mode; 174 }; 175 176 static struct perf_stat perf_stat; 177 #define STAT_RECORD perf_stat.record 178 179 static volatile int done = 0; 180 181 static struct perf_stat_config stat_config = { 182 .aggr_mode = AGGR_GLOBAL, 183 .scale = true, 184 .unit_width = 4, /* strlen("unit") */ 185 .run_count = 1, 186 .metric_only_len = METRIC_ONLY_LEN, 187 .walltime_nsecs_stats = &walltime_nsecs_stats, 188 .big_num = true, 189 }; 190 191 static inline void diff_timespec(struct timespec *r, struct timespec *a, 192 struct timespec *b) 193 { 194 r->tv_sec = a->tv_sec - b->tv_sec; 195 if (a->tv_nsec < b->tv_nsec) { 196 r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec; 197 r->tv_sec--; 198 } else { 199 r->tv_nsec = a->tv_nsec - b->tv_nsec ; 200 } 201 } 202 203 static void perf_stat__reset_stats(void) 204 { 205 int i; 206 207 perf_evlist__reset_stats(evsel_list); 208 perf_stat__reset_shadow_stats(); 209 210 for (i = 0; i < stat_config.stats_num; i++) 211 perf_stat__reset_shadow_per_stat(&stat_config.stats[i]); 212 } 213 214 static int process_synthesized_event(struct perf_tool *tool __maybe_unused, 215 union perf_event *event, 216 struct perf_sample *sample __maybe_unused, 217 struct machine *machine __maybe_unused) 218 { 219 if (perf_data__write(&perf_stat.data, event, event->header.size) < 0) { 220 pr_err("failed to write perf data, error: %m\n"); 221 return -1; 222 } 223 224 perf_stat.bytes_written += event->header.size; 225 return 0; 226 } 227 228 static int write_stat_round_event(u64 tm, u64 type) 229 { 230 return perf_event__synthesize_stat_round(NULL, tm, type, 231 process_synthesized_event, 232 NULL); 233 } 234 235 #define WRITE_STAT_ROUND_EVENT(time, interval) \ 236 write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval) 237 238 #define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y) 239 240 static int 241 perf_evsel__write_stat_event(struct evsel *counter, u32 cpu, u32 thread, 242 struct perf_counts_values *count) 243 { 244 struct perf_sample_id *sid = SID(counter, cpu, thread); 245 246 return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count, 247 process_synthesized_event, NULL); 248 } 249 250 static int read_single_counter(struct evsel *counter, int cpu, 251 int thread, struct timespec *rs) 252 { 253 if (counter->tool_event == PERF_TOOL_DURATION_TIME) { 254 u64 val = rs->tv_nsec + rs->tv_sec*1000000000ULL; 255 struct perf_counts_values *count = 256 perf_counts(counter->counts, cpu, thread); 257 count->ena = count->run = val; 258 count->val = val; 259 return 0; 260 } 261 return perf_evsel__read_counter(counter, cpu, thread); 262 } 263 264 /* 265 * Read out the results of a single counter: 266 * do not aggregate counts across CPUs in system-wide mode 267 */ 268 static int read_counter(struct evsel *counter, struct timespec *rs) 269 { 270 int nthreads = perf_thread_map__nr(evsel_list->core.threads); 271 int ncpus, cpu, thread; 272 273 if (target__has_cpu(&target) && !target__has_per_thread(&target)) 274 ncpus = perf_evsel__nr_cpus(counter); 275 else 276 ncpus = 1; 277 278 if (!counter->supported) 279 return -ENOENT; 280 281 if (counter->core.system_wide) 282 nthreads = 1; 283 284 for (thread = 0; thread < nthreads; thread++) { 285 for (cpu = 0; cpu < ncpus; cpu++) { 286 struct perf_counts_values *count; 287 288 count = perf_counts(counter->counts, cpu, thread); 289 290 /* 291 * The leader's group read loads data into its group members 292 * (via perf_evsel__read_counter) and sets threir count->loaded. 293 */ 294 if (!perf_counts__is_loaded(counter->counts, cpu, thread) && 295 read_single_counter(counter, cpu, thread, rs)) { 296 counter->counts->scaled = -1; 297 perf_counts(counter->counts, cpu, thread)->ena = 0; 298 perf_counts(counter->counts, cpu, thread)->run = 0; 299 return -1; 300 } 301 302 perf_counts__set_loaded(counter->counts, cpu, thread, false); 303 304 if (STAT_RECORD) { 305 if (perf_evsel__write_stat_event(counter, cpu, thread, count)) { 306 pr_err("failed to write stat event\n"); 307 return -1; 308 } 309 } 310 311 if (verbose > 1) { 312 fprintf(stat_config.output, 313 "%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 314 perf_evsel__name(counter), 315 cpu, 316 count->val, count->ena, count->run); 317 } 318 } 319 } 320 321 return 0; 322 } 323 324 static void read_counters(struct timespec *rs) 325 { 326 struct evsel *counter; 327 int ret; 328 329 evlist__for_each_entry(evsel_list, counter) { 330 ret = read_counter(counter, rs); 331 if (ret) 332 pr_debug("failed to read counter %s\n", counter->name); 333 334 if (ret == 0 && perf_stat_process_counter(&stat_config, counter)) 335 pr_warning("failed to process counter %s\n", counter->name); 336 } 337 } 338 339 static void process_interval(void) 340 { 341 struct timespec ts, rs; 342 343 clock_gettime(CLOCK_MONOTONIC, &ts); 344 diff_timespec(&rs, &ts, &ref_time); 345 346 read_counters(&rs); 347 348 if (STAT_RECORD) { 349 if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL)) 350 pr_err("failed to write stat round event\n"); 351 } 352 353 init_stats(&walltime_nsecs_stats); 354 update_stats(&walltime_nsecs_stats, stat_config.interval * 1000000); 355 print_counters(&rs, 0, NULL); 356 } 357 358 static void enable_counters(void) 359 { 360 if (stat_config.initial_delay) 361 usleep(stat_config.initial_delay * USEC_PER_MSEC); 362 363 /* 364 * We need to enable counters only if: 365 * - we don't have tracee (attaching to task or cpu) 366 * - we have initial delay configured 367 */ 368 if (!target__none(&target) || stat_config.initial_delay) 369 evlist__enable(evsel_list); 370 } 371 372 static void disable_counters(void) 373 { 374 /* 375 * If we don't have tracee (attaching to task or cpu), counters may 376 * still be running. To get accurate group ratios, we must stop groups 377 * from counting before reading their constituent counters. 378 */ 379 if (!target__none(&target)) 380 evlist__disable(evsel_list); 381 } 382 383 static volatile int workload_exec_errno; 384 385 /* 386 * perf_evlist__prepare_workload will send a SIGUSR1 387 * if the fork fails, since we asked by setting its 388 * want_signal to true. 389 */ 390 static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 391 void *ucontext __maybe_unused) 392 { 393 workload_exec_errno = info->si_value.sival_int; 394 } 395 396 static bool perf_evsel__should_store_id(struct evsel *counter) 397 { 398 return STAT_RECORD || counter->core.attr.read_format & PERF_FORMAT_ID; 399 } 400 401 static bool is_target_alive(struct target *_target, 402 struct perf_thread_map *threads) 403 { 404 struct stat st; 405 int i; 406 407 if (!target__has_task(_target)) 408 return true; 409 410 for (i = 0; i < threads->nr; i++) { 411 char path[PATH_MAX]; 412 413 scnprintf(path, PATH_MAX, "%s/%d", procfs__mountpoint(), 414 threads->map[i].pid); 415 416 if (!stat(path, &st)) 417 return true; 418 } 419 420 return false; 421 } 422 423 static int __run_perf_stat(int argc, const char **argv, int run_idx) 424 { 425 int interval = stat_config.interval; 426 int times = stat_config.times; 427 int timeout = stat_config.timeout; 428 char msg[BUFSIZ]; 429 unsigned long long t0, t1; 430 struct evsel *counter; 431 struct timespec ts; 432 size_t l; 433 int status = 0; 434 const bool forks = (argc > 0); 435 bool is_pipe = STAT_RECORD ? perf_stat.data.is_pipe : false; 436 437 if (interval) { 438 ts.tv_sec = interval / USEC_PER_MSEC; 439 ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC; 440 } else if (timeout) { 441 ts.tv_sec = timeout / USEC_PER_MSEC; 442 ts.tv_nsec = (timeout % USEC_PER_MSEC) * NSEC_PER_MSEC; 443 } else { 444 ts.tv_sec = 1; 445 ts.tv_nsec = 0; 446 } 447 448 if (forks) { 449 if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe, 450 workload_exec_failed_signal) < 0) { 451 perror("failed to prepare workload"); 452 return -1; 453 } 454 child_pid = evsel_list->workload.pid; 455 } 456 457 if (group) 458 perf_evlist__set_leader(evsel_list); 459 460 evlist__for_each_entry(evsel_list, counter) { 461 try_again: 462 if (create_perf_stat_counter(counter, &stat_config, &target) < 0) { 463 464 /* Weak group failed. Reset the group. */ 465 if ((errno == EINVAL || errno == EBADF) && 466 counter->leader != counter && 467 counter->weak_group) { 468 counter = perf_evlist__reset_weak_group(evsel_list, counter); 469 goto try_again; 470 } 471 472 /* 473 * PPC returns ENXIO for HW counters until 2.6.37 474 * (behavior changed with commit b0a873e). 475 */ 476 if (errno == EINVAL || errno == ENOSYS || 477 errno == ENOENT || errno == EOPNOTSUPP || 478 errno == ENXIO) { 479 if (verbose > 0) 480 ui__warning("%s event is not supported by the kernel.\n", 481 perf_evsel__name(counter)); 482 counter->supported = false; 483 484 if ((counter->leader != counter) || 485 !(counter->leader->core.nr_members > 1)) 486 continue; 487 } else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) { 488 if (verbose > 0) 489 ui__warning("%s\n", msg); 490 goto try_again; 491 } else if (target__has_per_thread(&target) && 492 evsel_list->core.threads && 493 evsel_list->core.threads->err_thread != -1) { 494 /* 495 * For global --per-thread case, skip current 496 * error thread. 497 */ 498 if (!thread_map__remove(evsel_list->core.threads, 499 evsel_list->core.threads->err_thread)) { 500 evsel_list->core.threads->err_thread = -1; 501 goto try_again; 502 } 503 } 504 505 perf_evsel__open_strerror(counter, &target, 506 errno, msg, sizeof(msg)); 507 ui__error("%s\n", msg); 508 509 if (child_pid != -1) 510 kill(child_pid, SIGTERM); 511 512 return -1; 513 } 514 counter->supported = true; 515 516 l = strlen(counter->unit); 517 if (l > stat_config.unit_width) 518 stat_config.unit_width = l; 519 520 if (perf_evsel__should_store_id(counter) && 521 perf_evsel__store_ids(counter, evsel_list)) 522 return -1; 523 } 524 525 if (perf_evlist__apply_filters(evsel_list, &counter)) { 526 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n", 527 counter->filter, perf_evsel__name(counter), errno, 528 str_error_r(errno, msg, sizeof(msg))); 529 return -1; 530 } 531 532 if (STAT_RECORD) { 533 int err, fd = perf_data__fd(&perf_stat.data); 534 535 if (is_pipe) { 536 err = perf_header__write_pipe(perf_data__fd(&perf_stat.data)); 537 } else { 538 err = perf_session__write_header(perf_stat.session, evsel_list, 539 fd, false); 540 } 541 542 if (err < 0) 543 return err; 544 545 err = perf_event__synthesize_stat_events(&stat_config, NULL, evsel_list, 546 process_synthesized_event, is_pipe); 547 if (err < 0) 548 return err; 549 } 550 551 /* 552 * Enable counters and exec the command: 553 */ 554 t0 = rdclock(); 555 clock_gettime(CLOCK_MONOTONIC, &ref_time); 556 557 if (forks) { 558 perf_evlist__start_workload(evsel_list); 559 enable_counters(); 560 561 if (interval || timeout) { 562 while (!waitpid(child_pid, &status, WNOHANG)) { 563 nanosleep(&ts, NULL); 564 if (timeout) 565 break; 566 process_interval(); 567 if (interval_count && !(--times)) 568 break; 569 } 570 } 571 if (child_pid != -1) 572 wait4(child_pid, &status, 0, &stat_config.ru_data); 573 574 if (workload_exec_errno) { 575 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg)); 576 pr_err("Workload failed: %s\n", emsg); 577 return -1; 578 } 579 580 if (WIFSIGNALED(status)) 581 psignal(WTERMSIG(status), argv[0]); 582 } else { 583 enable_counters(); 584 while (!done) { 585 nanosleep(&ts, NULL); 586 if (!is_target_alive(&target, evsel_list->core.threads)) 587 break; 588 if (timeout) 589 break; 590 if (interval) { 591 process_interval(); 592 if (interval_count && !(--times)) 593 break; 594 } 595 } 596 } 597 598 disable_counters(); 599 600 t1 = rdclock(); 601 602 if (stat_config.walltime_run_table) 603 stat_config.walltime_run[run_idx] = t1 - t0; 604 605 update_stats(&walltime_nsecs_stats, t1 - t0); 606 607 /* 608 * Closing a group leader splits the group, and as we only disable 609 * group leaders, results in remaining events becoming enabled. To 610 * avoid arbitrary skew, we must read all counters before closing any 611 * group leaders. 612 */ 613 read_counters(&(struct timespec) { .tv_nsec = t1-t0 }); 614 615 /* 616 * We need to keep evsel_list alive, because it's processed 617 * later the evsel_list will be closed after. 618 */ 619 if (!STAT_RECORD) 620 evlist__close(evsel_list); 621 622 return WEXITSTATUS(status); 623 } 624 625 static int run_perf_stat(int argc, const char **argv, int run_idx) 626 { 627 int ret; 628 629 if (pre_cmd) { 630 ret = system(pre_cmd); 631 if (ret) 632 return ret; 633 } 634 635 if (sync_run) 636 sync(); 637 638 ret = __run_perf_stat(argc, argv, run_idx); 639 if (ret) 640 return ret; 641 642 if (post_cmd) { 643 ret = system(post_cmd); 644 if (ret) 645 return ret; 646 } 647 648 return ret; 649 } 650 651 static void print_counters(struct timespec *ts, int argc, const char **argv) 652 { 653 /* Do not print anything if we record to the pipe. */ 654 if (STAT_RECORD && perf_stat.data.is_pipe) 655 return; 656 657 perf_evlist__print_counters(evsel_list, &stat_config, &target, 658 ts, argc, argv); 659 } 660 661 static volatile int signr = -1; 662 663 static void skip_signal(int signo) 664 { 665 if ((child_pid == -1) || stat_config.interval) 666 done = 1; 667 668 signr = signo; 669 /* 670 * render child_pid harmless 671 * won't send SIGTERM to a random 672 * process in case of race condition 673 * and fast PID recycling 674 */ 675 child_pid = -1; 676 } 677 678 static void sig_atexit(void) 679 { 680 sigset_t set, oset; 681 682 /* 683 * avoid race condition with SIGCHLD handler 684 * in skip_signal() which is modifying child_pid 685 * goal is to avoid send SIGTERM to a random 686 * process 687 */ 688 sigemptyset(&set); 689 sigaddset(&set, SIGCHLD); 690 sigprocmask(SIG_BLOCK, &set, &oset); 691 692 if (child_pid != -1) 693 kill(child_pid, SIGTERM); 694 695 sigprocmask(SIG_SETMASK, &oset, NULL); 696 697 if (signr == -1) 698 return; 699 700 signal(signr, SIG_DFL); 701 kill(getpid(), signr); 702 } 703 704 static int stat__set_big_num(const struct option *opt __maybe_unused, 705 const char *s __maybe_unused, int unset) 706 { 707 big_num_opt = unset ? 0 : 1; 708 return 0; 709 } 710 711 static int enable_metric_only(const struct option *opt __maybe_unused, 712 const char *s __maybe_unused, int unset) 713 { 714 force_metric_only = true; 715 stat_config.metric_only = !unset; 716 return 0; 717 } 718 719 static int parse_metric_groups(const struct option *opt, 720 const char *str, 721 int unset __maybe_unused) 722 { 723 return metricgroup__parse_groups(opt, str, &stat_config.metric_events); 724 } 725 726 static struct option stat_options[] = { 727 OPT_BOOLEAN('T', "transaction", &transaction_run, 728 "hardware transaction statistics"), 729 OPT_CALLBACK('e', "event", &evsel_list, "event", 730 "event selector. use 'perf list' to list available events", 731 parse_events_option), 732 OPT_CALLBACK(0, "filter", &evsel_list, "filter", 733 "event filter", parse_filter), 734 OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit, 735 "child tasks do not inherit counters"), 736 OPT_STRING('p', "pid", &target.pid, "pid", 737 "stat events on existing process id"), 738 OPT_STRING('t', "tid", &target.tid, "tid", 739 "stat events on existing thread id"), 740 OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 741 "system-wide collection from all CPUs"), 742 OPT_BOOLEAN('g', "group", &group, 743 "put the counters into a counter group"), 744 OPT_BOOLEAN(0, "scale", &stat_config.scale, 745 "Use --no-scale to disable counter scaling for multiplexing"), 746 OPT_INCR('v', "verbose", &verbose, 747 "be more verbose (show counter open errors, etc)"), 748 OPT_INTEGER('r', "repeat", &stat_config.run_count, 749 "repeat command and print average + stddev (max: 100, forever: 0)"), 750 OPT_BOOLEAN(0, "table", &stat_config.walltime_run_table, 751 "display details about each run (only with -r option)"), 752 OPT_BOOLEAN('n', "null", &stat_config.null_run, 753 "null run - dont start any counters"), 754 OPT_INCR('d', "detailed", &detailed_run, 755 "detailed run - start a lot of events"), 756 OPT_BOOLEAN('S', "sync", &sync_run, 757 "call sync() before starting a run"), 758 OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 759 "print large numbers with thousands\' separators", 760 stat__set_big_num), 761 OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 762 "list of cpus to monitor in system-wide"), 763 OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode, 764 "disable CPU count aggregation", AGGR_NONE), 765 OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"), 766 OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator", 767 "print counts with custom separator"), 768 OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 769 "monitor event in cgroup name only", parse_cgroups), 770 OPT_STRING('o', "output", &output_name, "file", "output file name"), 771 OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 772 OPT_INTEGER(0, "log-fd", &output_fd, 773 "log output to fd, instead of stderr"), 774 OPT_STRING(0, "pre", &pre_cmd, "command", 775 "command to run prior to the measured command"), 776 OPT_STRING(0, "post", &post_cmd, "command", 777 "command to run after to the measured command"), 778 OPT_UINTEGER('I', "interval-print", &stat_config.interval, 779 "print counts at regular interval in ms " 780 "(overhead is possible for values <= 100ms)"), 781 OPT_INTEGER(0, "interval-count", &stat_config.times, 782 "print counts for fixed number of times"), 783 OPT_BOOLEAN(0, "interval-clear", &stat_config.interval_clear, 784 "clear screen in between new interval"), 785 OPT_UINTEGER(0, "timeout", &stat_config.timeout, 786 "stop workload and print counts after a timeout period in ms (>= 10ms)"), 787 OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode, 788 "aggregate counts per processor socket", AGGR_SOCKET), 789 OPT_SET_UINT(0, "per-die", &stat_config.aggr_mode, 790 "aggregate counts per processor die", AGGR_DIE), 791 OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode, 792 "aggregate counts per physical processor core", AGGR_CORE), 793 OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode, 794 "aggregate counts per thread", AGGR_THREAD), 795 OPT_SET_UINT(0, "per-node", &stat_config.aggr_mode, 796 "aggregate counts per numa node", AGGR_NODE), 797 OPT_UINTEGER('D', "delay", &stat_config.initial_delay, 798 "ms to wait before starting measurement after program start"), 799 OPT_CALLBACK_NOOPT(0, "metric-only", &stat_config.metric_only, NULL, 800 "Only print computed metrics. No raw values", enable_metric_only), 801 OPT_BOOLEAN(0, "topdown", &topdown_run, 802 "measure topdown level 1 statistics"), 803 OPT_BOOLEAN(0, "smi-cost", &smi_cost, 804 "measure SMI cost"), 805 OPT_CALLBACK('M', "metrics", &evsel_list, "metric/metric group list", 806 "monitor specified metrics or metric groups (separated by ,)", 807 parse_metric_groups), 808 OPT_BOOLEAN_FLAG(0, "all-kernel", &stat_config.all_kernel, 809 "Configure all used events to run in kernel space.", 810 PARSE_OPT_EXCLUSIVE), 811 OPT_BOOLEAN_FLAG(0, "all-user", &stat_config.all_user, 812 "Configure all used events to run in user space.", 813 PARSE_OPT_EXCLUSIVE), 814 OPT_END() 815 }; 816 817 static int perf_stat__get_socket(struct perf_stat_config *config __maybe_unused, 818 struct perf_cpu_map *map, int cpu) 819 { 820 return cpu_map__get_socket(map, cpu, NULL); 821 } 822 823 static int perf_stat__get_die(struct perf_stat_config *config __maybe_unused, 824 struct perf_cpu_map *map, int cpu) 825 { 826 return cpu_map__get_die(map, cpu, NULL); 827 } 828 829 static int perf_stat__get_core(struct perf_stat_config *config __maybe_unused, 830 struct perf_cpu_map *map, int cpu) 831 { 832 return cpu_map__get_core(map, cpu, NULL); 833 } 834 835 static int perf_stat__get_node(struct perf_stat_config *config __maybe_unused, 836 struct perf_cpu_map *map, int cpu) 837 { 838 return cpu_map__get_node(map, cpu, NULL); 839 } 840 841 static int perf_stat__get_aggr(struct perf_stat_config *config, 842 aggr_get_id_t get_id, struct perf_cpu_map *map, int idx) 843 { 844 int cpu; 845 846 if (idx >= map->nr) 847 return -1; 848 849 cpu = map->map[idx]; 850 851 if (config->cpus_aggr_map->map[cpu] == -1) 852 config->cpus_aggr_map->map[cpu] = get_id(config, map, idx); 853 854 return config->cpus_aggr_map->map[cpu]; 855 } 856 857 static int perf_stat__get_socket_cached(struct perf_stat_config *config, 858 struct perf_cpu_map *map, int idx) 859 { 860 return perf_stat__get_aggr(config, perf_stat__get_socket, map, idx); 861 } 862 863 static int perf_stat__get_die_cached(struct perf_stat_config *config, 864 struct perf_cpu_map *map, int idx) 865 { 866 return perf_stat__get_aggr(config, perf_stat__get_die, map, idx); 867 } 868 869 static int perf_stat__get_core_cached(struct perf_stat_config *config, 870 struct perf_cpu_map *map, int idx) 871 { 872 return perf_stat__get_aggr(config, perf_stat__get_core, map, idx); 873 } 874 875 static int perf_stat__get_node_cached(struct perf_stat_config *config, 876 struct perf_cpu_map *map, int idx) 877 { 878 return perf_stat__get_aggr(config, perf_stat__get_node, map, idx); 879 } 880 881 static bool term_percore_set(void) 882 { 883 struct evsel *counter; 884 885 evlist__for_each_entry(evsel_list, counter) { 886 if (counter->percore) 887 return true; 888 } 889 890 return false; 891 } 892 893 static int perf_stat_init_aggr_mode(void) 894 { 895 int nr; 896 897 switch (stat_config.aggr_mode) { 898 case AGGR_SOCKET: 899 if (cpu_map__build_socket_map(evsel_list->core.cpus, &stat_config.aggr_map)) { 900 perror("cannot build socket map"); 901 return -1; 902 } 903 stat_config.aggr_get_id = perf_stat__get_socket_cached; 904 break; 905 case AGGR_DIE: 906 if (cpu_map__build_die_map(evsel_list->core.cpus, &stat_config.aggr_map)) { 907 perror("cannot build die map"); 908 return -1; 909 } 910 stat_config.aggr_get_id = perf_stat__get_die_cached; 911 break; 912 case AGGR_CORE: 913 if (cpu_map__build_core_map(evsel_list->core.cpus, &stat_config.aggr_map)) { 914 perror("cannot build core map"); 915 return -1; 916 } 917 stat_config.aggr_get_id = perf_stat__get_core_cached; 918 break; 919 case AGGR_NODE: 920 if (cpu_map__build_node_map(evsel_list->core.cpus, &stat_config.aggr_map)) { 921 perror("cannot build core map"); 922 return -1; 923 } 924 stat_config.aggr_get_id = perf_stat__get_node_cached; 925 break; 926 case AGGR_NONE: 927 if (term_percore_set()) { 928 if (cpu_map__build_core_map(evsel_list->core.cpus, 929 &stat_config.aggr_map)) { 930 perror("cannot build core map"); 931 return -1; 932 } 933 stat_config.aggr_get_id = perf_stat__get_core_cached; 934 } 935 break; 936 case AGGR_GLOBAL: 937 case AGGR_THREAD: 938 case AGGR_UNSET: 939 default: 940 break; 941 } 942 943 /* 944 * The evsel_list->cpus is the base we operate on, 945 * taking the highest cpu number to be the size of 946 * the aggregation translate cpumap. 947 */ 948 nr = perf_cpu_map__max(evsel_list->core.cpus); 949 stat_config.cpus_aggr_map = perf_cpu_map__empty_new(nr + 1); 950 return stat_config.cpus_aggr_map ? 0 : -ENOMEM; 951 } 952 953 static void perf_stat__exit_aggr_mode(void) 954 { 955 perf_cpu_map__put(stat_config.aggr_map); 956 perf_cpu_map__put(stat_config.cpus_aggr_map); 957 stat_config.aggr_map = NULL; 958 stat_config.cpus_aggr_map = NULL; 959 } 960 961 static inline int perf_env__get_cpu(struct perf_env *env, struct perf_cpu_map *map, int idx) 962 { 963 int cpu; 964 965 if (idx > map->nr) 966 return -1; 967 968 cpu = map->map[idx]; 969 970 if (cpu >= env->nr_cpus_avail) 971 return -1; 972 973 return cpu; 974 } 975 976 static int perf_env__get_socket(struct perf_cpu_map *map, int idx, void *data) 977 { 978 struct perf_env *env = data; 979 int cpu = perf_env__get_cpu(env, map, idx); 980 981 return cpu == -1 ? -1 : env->cpu[cpu].socket_id; 982 } 983 984 static int perf_env__get_die(struct perf_cpu_map *map, int idx, void *data) 985 { 986 struct perf_env *env = data; 987 int die_id = -1, cpu = perf_env__get_cpu(env, map, idx); 988 989 if (cpu != -1) { 990 /* 991 * Encode socket in bit range 15:8 992 * die_id is relative to socket, 993 * we need a global id. So we combine 994 * socket + die id 995 */ 996 if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n")) 997 return -1; 998 999 if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n")) 1000 return -1; 1001 1002 die_id = (env->cpu[cpu].socket_id << 8) | (env->cpu[cpu].die_id & 0xff); 1003 } 1004 1005 return die_id; 1006 } 1007 1008 static int perf_env__get_core(struct perf_cpu_map *map, int idx, void *data) 1009 { 1010 struct perf_env *env = data; 1011 int core = -1, cpu = perf_env__get_cpu(env, map, idx); 1012 1013 if (cpu != -1) { 1014 /* 1015 * Encode socket in bit range 31:24 1016 * encode die id in bit range 23:16 1017 * core_id is relative to socket and die, 1018 * we need a global id. So we combine 1019 * socket + die id + core id 1020 */ 1021 if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n")) 1022 return -1; 1023 1024 if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n")) 1025 return -1; 1026 1027 if (WARN_ONCE(env->cpu[cpu].core_id >> 16, "The core id number is too big.\n")) 1028 return -1; 1029 1030 core = (env->cpu[cpu].socket_id << 24) | 1031 (env->cpu[cpu].die_id << 16) | 1032 (env->cpu[cpu].core_id & 0xffff); 1033 } 1034 1035 return core; 1036 } 1037 1038 static int perf_env__get_node(struct perf_cpu_map *map, int idx, void *data) 1039 { 1040 int cpu = perf_env__get_cpu(data, map, idx); 1041 1042 return perf_env__numa_node(data, cpu); 1043 } 1044 1045 static int perf_env__build_socket_map(struct perf_env *env, struct perf_cpu_map *cpus, 1046 struct perf_cpu_map **sockp) 1047 { 1048 return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env); 1049 } 1050 1051 static int perf_env__build_die_map(struct perf_env *env, struct perf_cpu_map *cpus, 1052 struct perf_cpu_map **diep) 1053 { 1054 return cpu_map__build_map(cpus, diep, perf_env__get_die, env); 1055 } 1056 1057 static int perf_env__build_core_map(struct perf_env *env, struct perf_cpu_map *cpus, 1058 struct perf_cpu_map **corep) 1059 { 1060 return cpu_map__build_map(cpus, corep, perf_env__get_core, env); 1061 } 1062 1063 static int perf_env__build_node_map(struct perf_env *env, struct perf_cpu_map *cpus, 1064 struct perf_cpu_map **nodep) 1065 { 1066 return cpu_map__build_map(cpus, nodep, perf_env__get_node, env); 1067 } 1068 1069 static int perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused, 1070 struct perf_cpu_map *map, int idx) 1071 { 1072 return perf_env__get_socket(map, idx, &perf_stat.session->header.env); 1073 } 1074 static int perf_stat__get_die_file(struct perf_stat_config *config __maybe_unused, 1075 struct perf_cpu_map *map, int idx) 1076 { 1077 return perf_env__get_die(map, idx, &perf_stat.session->header.env); 1078 } 1079 1080 static int perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused, 1081 struct perf_cpu_map *map, int idx) 1082 { 1083 return perf_env__get_core(map, idx, &perf_stat.session->header.env); 1084 } 1085 1086 static int perf_stat__get_node_file(struct perf_stat_config *config __maybe_unused, 1087 struct perf_cpu_map *map, int idx) 1088 { 1089 return perf_env__get_node(map, idx, &perf_stat.session->header.env); 1090 } 1091 1092 static int perf_stat_init_aggr_mode_file(struct perf_stat *st) 1093 { 1094 struct perf_env *env = &st->session->header.env; 1095 1096 switch (stat_config.aggr_mode) { 1097 case AGGR_SOCKET: 1098 if (perf_env__build_socket_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { 1099 perror("cannot build socket map"); 1100 return -1; 1101 } 1102 stat_config.aggr_get_id = perf_stat__get_socket_file; 1103 break; 1104 case AGGR_DIE: 1105 if (perf_env__build_die_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { 1106 perror("cannot build die map"); 1107 return -1; 1108 } 1109 stat_config.aggr_get_id = perf_stat__get_die_file; 1110 break; 1111 case AGGR_CORE: 1112 if (perf_env__build_core_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { 1113 perror("cannot build core map"); 1114 return -1; 1115 } 1116 stat_config.aggr_get_id = perf_stat__get_core_file; 1117 break; 1118 case AGGR_NODE: 1119 if (perf_env__build_node_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { 1120 perror("cannot build core map"); 1121 return -1; 1122 } 1123 stat_config.aggr_get_id = perf_stat__get_node_file; 1124 break; 1125 case AGGR_NONE: 1126 case AGGR_GLOBAL: 1127 case AGGR_THREAD: 1128 case AGGR_UNSET: 1129 default: 1130 break; 1131 } 1132 1133 return 0; 1134 } 1135 1136 static int topdown_filter_events(const char **attr, char **str, bool use_group) 1137 { 1138 int off = 0; 1139 int i; 1140 int len = 0; 1141 char *s; 1142 1143 for (i = 0; attr[i]; i++) { 1144 if (pmu_have_event("cpu", attr[i])) { 1145 len += strlen(attr[i]) + 1; 1146 attr[i - off] = attr[i]; 1147 } else 1148 off++; 1149 } 1150 attr[i - off] = NULL; 1151 1152 *str = malloc(len + 1 + 2); 1153 if (!*str) 1154 return -1; 1155 s = *str; 1156 if (i - off == 0) { 1157 *s = 0; 1158 return 0; 1159 } 1160 if (use_group) 1161 *s++ = '{'; 1162 for (i = 0; attr[i]; i++) { 1163 strcpy(s, attr[i]); 1164 s += strlen(s); 1165 *s++ = ','; 1166 } 1167 if (use_group) { 1168 s[-1] = '}'; 1169 *s = 0; 1170 } else 1171 s[-1] = 0; 1172 return 0; 1173 } 1174 1175 __weak bool arch_topdown_check_group(bool *warn) 1176 { 1177 *warn = false; 1178 return false; 1179 } 1180 1181 __weak void arch_topdown_group_warn(void) 1182 { 1183 } 1184 1185 /* 1186 * Add default attributes, if there were no attributes specified or 1187 * if -d/--detailed, -d -d or -d -d -d is used: 1188 */ 1189 static int add_default_attributes(void) 1190 { 1191 int err; 1192 struct perf_event_attr default_attrs0[] = { 1193 1194 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 1195 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 1196 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 1197 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 1198 1199 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 1200 }; 1201 struct perf_event_attr frontend_attrs[] = { 1202 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 1203 }; 1204 struct perf_event_attr backend_attrs[] = { 1205 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 1206 }; 1207 struct perf_event_attr default_attrs1[] = { 1208 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 1209 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 1210 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 1211 1212 }; 1213 1214 /* 1215 * Detailed stats (-d), covering the L1 and last level data caches: 1216 */ 1217 struct perf_event_attr detailed_attrs[] = { 1218 1219 { .type = PERF_TYPE_HW_CACHE, 1220 .config = 1221 PERF_COUNT_HW_CACHE_L1D << 0 | 1222 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1223 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1224 1225 { .type = PERF_TYPE_HW_CACHE, 1226 .config = 1227 PERF_COUNT_HW_CACHE_L1D << 0 | 1228 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1229 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1230 1231 { .type = PERF_TYPE_HW_CACHE, 1232 .config = 1233 PERF_COUNT_HW_CACHE_LL << 0 | 1234 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1235 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1236 1237 { .type = PERF_TYPE_HW_CACHE, 1238 .config = 1239 PERF_COUNT_HW_CACHE_LL << 0 | 1240 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1241 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1242 }; 1243 1244 /* 1245 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 1246 */ 1247 struct perf_event_attr very_detailed_attrs[] = { 1248 1249 { .type = PERF_TYPE_HW_CACHE, 1250 .config = 1251 PERF_COUNT_HW_CACHE_L1I << 0 | 1252 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1253 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1254 1255 { .type = PERF_TYPE_HW_CACHE, 1256 .config = 1257 PERF_COUNT_HW_CACHE_L1I << 0 | 1258 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1259 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1260 1261 { .type = PERF_TYPE_HW_CACHE, 1262 .config = 1263 PERF_COUNT_HW_CACHE_DTLB << 0 | 1264 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1265 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1266 1267 { .type = PERF_TYPE_HW_CACHE, 1268 .config = 1269 PERF_COUNT_HW_CACHE_DTLB << 0 | 1270 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1271 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1272 1273 { .type = PERF_TYPE_HW_CACHE, 1274 .config = 1275 PERF_COUNT_HW_CACHE_ITLB << 0 | 1276 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1277 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1278 1279 { .type = PERF_TYPE_HW_CACHE, 1280 .config = 1281 PERF_COUNT_HW_CACHE_ITLB << 0 | 1282 (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1283 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1284 1285 }; 1286 1287 /* 1288 * Very, very detailed stats (-d -d -d), adding prefetch events: 1289 */ 1290 struct perf_event_attr very_very_detailed_attrs[] = { 1291 1292 { .type = PERF_TYPE_HW_CACHE, 1293 .config = 1294 PERF_COUNT_HW_CACHE_L1D << 0 | 1295 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1296 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1297 1298 { .type = PERF_TYPE_HW_CACHE, 1299 .config = 1300 PERF_COUNT_HW_CACHE_L1D << 0 | 1301 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1302 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1303 }; 1304 struct parse_events_error errinfo; 1305 1306 /* Set attrs if no event is selected and !null_run: */ 1307 if (stat_config.null_run) 1308 return 0; 1309 1310 bzero(&errinfo, sizeof(errinfo)); 1311 if (transaction_run) { 1312 /* Handle -T as -M transaction. Once platform specific metrics 1313 * support has been added to the json files, all archictures 1314 * will use this approach. To determine transaction support 1315 * on an architecture test for such a metric name. 1316 */ 1317 if (metricgroup__has_metric("transaction")) { 1318 struct option opt = { .value = &evsel_list }; 1319 1320 return metricgroup__parse_groups(&opt, "transaction", 1321 &stat_config.metric_events); 1322 } 1323 1324 if (pmu_have_event("cpu", "cycles-ct") && 1325 pmu_have_event("cpu", "el-start")) 1326 err = parse_events(evsel_list, transaction_attrs, 1327 &errinfo); 1328 else 1329 err = parse_events(evsel_list, 1330 transaction_limited_attrs, 1331 &errinfo); 1332 if (err) { 1333 fprintf(stderr, "Cannot set up transaction events\n"); 1334 parse_events_print_error(&errinfo, transaction_attrs); 1335 return -1; 1336 } 1337 return 0; 1338 } 1339 1340 if (smi_cost) { 1341 int smi; 1342 1343 if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) { 1344 fprintf(stderr, "freeze_on_smi is not supported.\n"); 1345 return -1; 1346 } 1347 1348 if (!smi) { 1349 if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) { 1350 fprintf(stderr, "Failed to set freeze_on_smi.\n"); 1351 return -1; 1352 } 1353 smi_reset = true; 1354 } 1355 1356 if (pmu_have_event("msr", "aperf") && 1357 pmu_have_event("msr", "smi")) { 1358 if (!force_metric_only) 1359 stat_config.metric_only = true; 1360 err = parse_events(evsel_list, smi_cost_attrs, &errinfo); 1361 } else { 1362 fprintf(stderr, "To measure SMI cost, it needs " 1363 "msr/aperf/, msr/smi/ and cpu/cycles/ support\n"); 1364 parse_events_print_error(&errinfo, smi_cost_attrs); 1365 return -1; 1366 } 1367 if (err) { 1368 parse_events_print_error(&errinfo, smi_cost_attrs); 1369 fprintf(stderr, "Cannot set up SMI cost events\n"); 1370 return -1; 1371 } 1372 return 0; 1373 } 1374 1375 if (topdown_run) { 1376 char *str = NULL; 1377 bool warn = false; 1378 1379 if (stat_config.aggr_mode != AGGR_GLOBAL && 1380 stat_config.aggr_mode != AGGR_CORE) { 1381 pr_err("top down event configuration requires --per-core mode\n"); 1382 return -1; 1383 } 1384 stat_config.aggr_mode = AGGR_CORE; 1385 if (nr_cgroups || !target__has_cpu(&target)) { 1386 pr_err("top down event configuration requires system-wide mode (-a)\n"); 1387 return -1; 1388 } 1389 1390 if (!force_metric_only) 1391 stat_config.metric_only = true; 1392 if (topdown_filter_events(topdown_attrs, &str, 1393 arch_topdown_check_group(&warn)) < 0) { 1394 pr_err("Out of memory\n"); 1395 return -1; 1396 } 1397 if (topdown_attrs[0] && str) { 1398 if (warn) 1399 arch_topdown_group_warn(); 1400 err = parse_events(evsel_list, str, &errinfo); 1401 if (err) { 1402 fprintf(stderr, 1403 "Cannot set up top down events %s: %d\n", 1404 str, err); 1405 parse_events_print_error(&errinfo, str); 1406 free(str); 1407 return -1; 1408 } 1409 } else { 1410 fprintf(stderr, "System does not support topdown\n"); 1411 return -1; 1412 } 1413 free(str); 1414 } 1415 1416 if (!evsel_list->core.nr_entries) { 1417 if (target__has_cpu(&target)) 1418 default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK; 1419 1420 if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0) 1421 return -1; 1422 if (pmu_have_event("cpu", "stalled-cycles-frontend")) { 1423 if (perf_evlist__add_default_attrs(evsel_list, 1424 frontend_attrs) < 0) 1425 return -1; 1426 } 1427 if (pmu_have_event("cpu", "stalled-cycles-backend")) { 1428 if (perf_evlist__add_default_attrs(evsel_list, 1429 backend_attrs) < 0) 1430 return -1; 1431 } 1432 if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0) 1433 return -1; 1434 } 1435 1436 /* Detailed events get appended to the event list: */ 1437 1438 if (detailed_run < 1) 1439 return 0; 1440 1441 /* Append detailed run extra attributes: */ 1442 if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 1443 return -1; 1444 1445 if (detailed_run < 2) 1446 return 0; 1447 1448 /* Append very detailed run extra attributes: */ 1449 if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 1450 return -1; 1451 1452 if (detailed_run < 3) 1453 return 0; 1454 1455 /* Append very, very detailed run extra attributes: */ 1456 return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 1457 } 1458 1459 static const char * const stat_record_usage[] = { 1460 "perf stat record [<options>]", 1461 NULL, 1462 }; 1463 1464 static void init_features(struct perf_session *session) 1465 { 1466 int feat; 1467 1468 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++) 1469 perf_header__set_feat(&session->header, feat); 1470 1471 perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT); 1472 perf_header__clear_feat(&session->header, HEADER_BUILD_ID); 1473 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA); 1474 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK); 1475 perf_header__clear_feat(&session->header, HEADER_AUXTRACE); 1476 } 1477 1478 static int __cmd_record(int argc, const char **argv) 1479 { 1480 struct perf_session *session; 1481 struct perf_data *data = &perf_stat.data; 1482 1483 argc = parse_options(argc, argv, stat_options, stat_record_usage, 1484 PARSE_OPT_STOP_AT_NON_OPTION); 1485 1486 if (output_name) 1487 data->path = output_name; 1488 1489 if (stat_config.run_count != 1 || forever) { 1490 pr_err("Cannot use -r option with perf stat record.\n"); 1491 return -1; 1492 } 1493 1494 session = perf_session__new(data, false, NULL); 1495 if (IS_ERR(session)) { 1496 pr_err("Perf session creation failed\n"); 1497 return PTR_ERR(session); 1498 } 1499 1500 init_features(session); 1501 1502 session->evlist = evsel_list; 1503 perf_stat.session = session; 1504 perf_stat.record = true; 1505 return argc; 1506 } 1507 1508 static int process_stat_round_event(struct perf_session *session, 1509 union perf_event *event) 1510 { 1511 struct perf_record_stat_round *stat_round = &event->stat_round; 1512 struct evsel *counter; 1513 struct timespec tsh, *ts = NULL; 1514 const char **argv = session->header.env.cmdline_argv; 1515 int argc = session->header.env.nr_cmdline; 1516 1517 evlist__for_each_entry(evsel_list, counter) 1518 perf_stat_process_counter(&stat_config, counter); 1519 1520 if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL) 1521 update_stats(&walltime_nsecs_stats, stat_round->time); 1522 1523 if (stat_config.interval && stat_round->time) { 1524 tsh.tv_sec = stat_round->time / NSEC_PER_SEC; 1525 tsh.tv_nsec = stat_round->time % NSEC_PER_SEC; 1526 ts = &tsh; 1527 } 1528 1529 print_counters(ts, argc, argv); 1530 return 0; 1531 } 1532 1533 static 1534 int process_stat_config_event(struct perf_session *session, 1535 union perf_event *event) 1536 { 1537 struct perf_tool *tool = session->tool; 1538 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1539 1540 perf_event__read_stat_config(&stat_config, &event->stat_config); 1541 1542 if (perf_cpu_map__empty(st->cpus)) { 1543 if (st->aggr_mode != AGGR_UNSET) 1544 pr_warning("warning: processing task data, aggregation mode not set\n"); 1545 return 0; 1546 } 1547 1548 if (st->aggr_mode != AGGR_UNSET) 1549 stat_config.aggr_mode = st->aggr_mode; 1550 1551 if (perf_stat.data.is_pipe) 1552 perf_stat_init_aggr_mode(); 1553 else 1554 perf_stat_init_aggr_mode_file(st); 1555 1556 return 0; 1557 } 1558 1559 static int set_maps(struct perf_stat *st) 1560 { 1561 if (!st->cpus || !st->threads) 1562 return 0; 1563 1564 if (WARN_ONCE(st->maps_allocated, "stats double allocation\n")) 1565 return -EINVAL; 1566 1567 perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads); 1568 1569 if (perf_evlist__alloc_stats(evsel_list, true)) 1570 return -ENOMEM; 1571 1572 st->maps_allocated = true; 1573 return 0; 1574 } 1575 1576 static 1577 int process_thread_map_event(struct perf_session *session, 1578 union perf_event *event) 1579 { 1580 struct perf_tool *tool = session->tool; 1581 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1582 1583 if (st->threads) { 1584 pr_warning("Extra thread map event, ignoring.\n"); 1585 return 0; 1586 } 1587 1588 st->threads = thread_map__new_event(&event->thread_map); 1589 if (!st->threads) 1590 return -ENOMEM; 1591 1592 return set_maps(st); 1593 } 1594 1595 static 1596 int process_cpu_map_event(struct perf_session *session, 1597 union perf_event *event) 1598 { 1599 struct perf_tool *tool = session->tool; 1600 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1601 struct perf_cpu_map *cpus; 1602 1603 if (st->cpus) { 1604 pr_warning("Extra cpu map event, ignoring.\n"); 1605 return 0; 1606 } 1607 1608 cpus = cpu_map__new_data(&event->cpu_map.data); 1609 if (!cpus) 1610 return -ENOMEM; 1611 1612 st->cpus = cpus; 1613 return set_maps(st); 1614 } 1615 1616 static int runtime_stat_new(struct perf_stat_config *config, int nthreads) 1617 { 1618 int i; 1619 1620 config->stats = calloc(nthreads, sizeof(struct runtime_stat)); 1621 if (!config->stats) 1622 return -1; 1623 1624 config->stats_num = nthreads; 1625 1626 for (i = 0; i < nthreads; i++) 1627 runtime_stat__init(&config->stats[i]); 1628 1629 return 0; 1630 } 1631 1632 static void runtime_stat_delete(struct perf_stat_config *config) 1633 { 1634 int i; 1635 1636 if (!config->stats) 1637 return; 1638 1639 for (i = 0; i < config->stats_num; i++) 1640 runtime_stat__exit(&config->stats[i]); 1641 1642 zfree(&config->stats); 1643 } 1644 1645 static const char * const stat_report_usage[] = { 1646 "perf stat report [<options>]", 1647 NULL, 1648 }; 1649 1650 static struct perf_stat perf_stat = { 1651 .tool = { 1652 .attr = perf_event__process_attr, 1653 .event_update = perf_event__process_event_update, 1654 .thread_map = process_thread_map_event, 1655 .cpu_map = process_cpu_map_event, 1656 .stat_config = process_stat_config_event, 1657 .stat = perf_event__process_stat_event, 1658 .stat_round = process_stat_round_event, 1659 }, 1660 .aggr_mode = AGGR_UNSET, 1661 }; 1662 1663 static int __cmd_report(int argc, const char **argv) 1664 { 1665 struct perf_session *session; 1666 const struct option options[] = { 1667 OPT_STRING('i', "input", &input_name, "file", "input file name"), 1668 OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode, 1669 "aggregate counts per processor socket", AGGR_SOCKET), 1670 OPT_SET_UINT(0, "per-die", &perf_stat.aggr_mode, 1671 "aggregate counts per processor die", AGGR_DIE), 1672 OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode, 1673 "aggregate counts per physical processor core", AGGR_CORE), 1674 OPT_SET_UINT(0, "per-node", &perf_stat.aggr_mode, 1675 "aggregate counts per numa node", AGGR_NODE), 1676 OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode, 1677 "disable CPU count aggregation", AGGR_NONE), 1678 OPT_END() 1679 }; 1680 struct stat st; 1681 int ret; 1682 1683 argc = parse_options(argc, argv, options, stat_report_usage, 0); 1684 1685 if (!input_name || !strlen(input_name)) { 1686 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) 1687 input_name = "-"; 1688 else 1689 input_name = "perf.data"; 1690 } 1691 1692 perf_stat.data.path = input_name; 1693 perf_stat.data.mode = PERF_DATA_MODE_READ; 1694 1695 session = perf_session__new(&perf_stat.data, false, &perf_stat.tool); 1696 if (IS_ERR(session)) 1697 return PTR_ERR(session); 1698 1699 perf_stat.session = session; 1700 stat_config.output = stderr; 1701 evsel_list = session->evlist; 1702 1703 ret = perf_session__process_events(session); 1704 if (ret) 1705 return ret; 1706 1707 perf_session__delete(session); 1708 return 0; 1709 } 1710 1711 static void setup_system_wide(int forks) 1712 { 1713 /* 1714 * Make system wide (-a) the default target if 1715 * no target was specified and one of following 1716 * conditions is met: 1717 * 1718 * - there's no workload specified 1719 * - there is workload specified but all requested 1720 * events are system wide events 1721 */ 1722 if (!target__none(&target)) 1723 return; 1724 1725 if (!forks) 1726 target.system_wide = true; 1727 else { 1728 struct evsel *counter; 1729 1730 evlist__for_each_entry(evsel_list, counter) { 1731 if (!counter->core.system_wide) 1732 return; 1733 } 1734 1735 if (evsel_list->core.nr_entries) 1736 target.system_wide = true; 1737 } 1738 } 1739 1740 int cmd_stat(int argc, const char **argv) 1741 { 1742 const char * const stat_usage[] = { 1743 "perf stat [<options>] [<command>]", 1744 NULL 1745 }; 1746 int status = -EINVAL, run_idx; 1747 const char *mode; 1748 FILE *output = stderr; 1749 unsigned int interval, timeout; 1750 const char * const stat_subcommands[] = { "record", "report" }; 1751 1752 setlocale(LC_ALL, ""); 1753 1754 evsel_list = evlist__new(); 1755 if (evsel_list == NULL) 1756 return -ENOMEM; 1757 1758 parse_events__shrink_config_terms(); 1759 1760 /* String-parsing callback-based options would segfault when negated */ 1761 set_option_flag(stat_options, 'e', "event", PARSE_OPT_NONEG); 1762 set_option_flag(stat_options, 'M', "metrics", PARSE_OPT_NONEG); 1763 set_option_flag(stat_options, 'G', "cgroup", PARSE_OPT_NONEG); 1764 1765 argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands, 1766 (const char **) stat_usage, 1767 PARSE_OPT_STOP_AT_NON_OPTION); 1768 perf_stat__collect_metric_expr(evsel_list); 1769 perf_stat__init_shadow_stats(); 1770 1771 if (stat_config.csv_sep) { 1772 stat_config.csv_output = true; 1773 if (!strcmp(stat_config.csv_sep, "\\t")) 1774 stat_config.csv_sep = "\t"; 1775 } else 1776 stat_config.csv_sep = DEFAULT_SEPARATOR; 1777 1778 if (argc && !strncmp(argv[0], "rec", 3)) { 1779 argc = __cmd_record(argc, argv); 1780 if (argc < 0) 1781 return -1; 1782 } else if (argc && !strncmp(argv[0], "rep", 3)) 1783 return __cmd_report(argc, argv); 1784 1785 interval = stat_config.interval; 1786 timeout = stat_config.timeout; 1787 1788 /* 1789 * For record command the -o is already taken care of. 1790 */ 1791 if (!STAT_RECORD && output_name && strcmp(output_name, "-")) 1792 output = NULL; 1793 1794 if (output_name && output_fd) { 1795 fprintf(stderr, "cannot use both --output and --log-fd\n"); 1796 parse_options_usage(stat_usage, stat_options, "o", 1); 1797 parse_options_usage(NULL, stat_options, "log-fd", 0); 1798 goto out; 1799 } 1800 1801 if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) { 1802 fprintf(stderr, "--metric-only is not supported with --per-thread\n"); 1803 goto out; 1804 } 1805 1806 if (stat_config.metric_only && stat_config.run_count > 1) { 1807 fprintf(stderr, "--metric-only is not supported with -r\n"); 1808 goto out; 1809 } 1810 1811 if (stat_config.walltime_run_table && stat_config.run_count <= 1) { 1812 fprintf(stderr, "--table is only supported with -r\n"); 1813 parse_options_usage(stat_usage, stat_options, "r", 1); 1814 parse_options_usage(NULL, stat_options, "table", 0); 1815 goto out; 1816 } 1817 1818 if (output_fd < 0) { 1819 fprintf(stderr, "argument to --log-fd must be a > 0\n"); 1820 parse_options_usage(stat_usage, stat_options, "log-fd", 0); 1821 goto out; 1822 } 1823 1824 if (!output) { 1825 struct timespec tm; 1826 mode = append_file ? "a" : "w"; 1827 1828 output = fopen(output_name, mode); 1829 if (!output) { 1830 perror("failed to create output file"); 1831 return -1; 1832 } 1833 clock_gettime(CLOCK_REALTIME, &tm); 1834 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 1835 } else if (output_fd > 0) { 1836 mode = append_file ? "a" : "w"; 1837 output = fdopen(output_fd, mode); 1838 if (!output) { 1839 perror("Failed opening logfd"); 1840 return -errno; 1841 } 1842 } 1843 1844 stat_config.output = output; 1845 1846 /* 1847 * let the spreadsheet do the pretty-printing 1848 */ 1849 if (stat_config.csv_output) { 1850 /* User explicitly passed -B? */ 1851 if (big_num_opt == 1) { 1852 fprintf(stderr, "-B option not supported with -x\n"); 1853 parse_options_usage(stat_usage, stat_options, "B", 1); 1854 parse_options_usage(NULL, stat_options, "x", 1); 1855 goto out; 1856 } else /* Nope, so disable big number formatting */ 1857 stat_config.big_num = false; 1858 } else if (big_num_opt == 0) /* User passed --no-big-num */ 1859 stat_config.big_num = false; 1860 1861 setup_system_wide(argc); 1862 1863 /* 1864 * Display user/system times only for single 1865 * run and when there's specified tracee. 1866 */ 1867 if ((stat_config.run_count == 1) && target__none(&target)) 1868 stat_config.ru_display = true; 1869 1870 if (stat_config.run_count < 0) { 1871 pr_err("Run count must be a positive number\n"); 1872 parse_options_usage(stat_usage, stat_options, "r", 1); 1873 goto out; 1874 } else if (stat_config.run_count == 0) { 1875 forever = true; 1876 stat_config.run_count = 1; 1877 } 1878 1879 if (stat_config.walltime_run_table) { 1880 stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0])); 1881 if (!stat_config.walltime_run) { 1882 pr_err("failed to setup -r option"); 1883 goto out; 1884 } 1885 } 1886 1887 if ((stat_config.aggr_mode == AGGR_THREAD) && 1888 !target__has_task(&target)) { 1889 if (!target.system_wide || target.cpu_list) { 1890 fprintf(stderr, "The --per-thread option is only " 1891 "available when monitoring via -p -t -a " 1892 "options or only --per-thread.\n"); 1893 parse_options_usage(NULL, stat_options, "p", 1); 1894 parse_options_usage(NULL, stat_options, "t", 1); 1895 goto out; 1896 } 1897 } 1898 1899 /* 1900 * no_aggr, cgroup are for system-wide only 1901 * --per-thread is aggregated per thread, we dont mix it with cpu mode 1902 */ 1903 if (((stat_config.aggr_mode != AGGR_GLOBAL && 1904 stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) && 1905 !target__has_cpu(&target)) { 1906 fprintf(stderr, "both cgroup and no-aggregation " 1907 "modes only available in system-wide mode\n"); 1908 1909 parse_options_usage(stat_usage, stat_options, "G", 1); 1910 parse_options_usage(NULL, stat_options, "A", 1); 1911 parse_options_usage(NULL, stat_options, "a", 1); 1912 goto out; 1913 } 1914 1915 if (add_default_attributes()) 1916 goto out; 1917 1918 target__validate(&target); 1919 1920 if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide)) 1921 target.per_thread = true; 1922 1923 if (perf_evlist__create_maps(evsel_list, &target) < 0) { 1924 if (target__has_task(&target)) { 1925 pr_err("Problems finding threads of monitor\n"); 1926 parse_options_usage(stat_usage, stat_options, "p", 1); 1927 parse_options_usage(NULL, stat_options, "t", 1); 1928 } else if (target__has_cpu(&target)) { 1929 perror("failed to parse CPUs map"); 1930 parse_options_usage(stat_usage, stat_options, "C", 1); 1931 parse_options_usage(NULL, stat_options, "a", 1); 1932 } 1933 goto out; 1934 } 1935 1936 /* 1937 * Initialize thread_map with comm names, 1938 * so we could print it out on output. 1939 */ 1940 if (stat_config.aggr_mode == AGGR_THREAD) { 1941 thread_map__read_comms(evsel_list->core.threads); 1942 if (target.system_wide) { 1943 if (runtime_stat_new(&stat_config, 1944 perf_thread_map__nr(evsel_list->core.threads))) { 1945 goto out; 1946 } 1947 } 1948 } 1949 1950 if (stat_config.aggr_mode == AGGR_NODE) 1951 cpu__setup_cpunode_map(); 1952 1953 if (stat_config.times && interval) 1954 interval_count = true; 1955 else if (stat_config.times && !interval) { 1956 pr_err("interval-count option should be used together with " 1957 "interval-print.\n"); 1958 parse_options_usage(stat_usage, stat_options, "interval-count", 0); 1959 parse_options_usage(stat_usage, stat_options, "I", 1); 1960 goto out; 1961 } 1962 1963 if (timeout && timeout < 100) { 1964 if (timeout < 10) { 1965 pr_err("timeout must be >= 10ms.\n"); 1966 parse_options_usage(stat_usage, stat_options, "timeout", 0); 1967 goto out; 1968 } else 1969 pr_warning("timeout < 100ms. " 1970 "The overhead percentage could be high in some cases. " 1971 "Please proceed with caution.\n"); 1972 } 1973 if (timeout && interval) { 1974 pr_err("timeout option is not supported with interval-print.\n"); 1975 parse_options_usage(stat_usage, stat_options, "timeout", 0); 1976 parse_options_usage(stat_usage, stat_options, "I", 1); 1977 goto out; 1978 } 1979 1980 if (perf_evlist__alloc_stats(evsel_list, interval)) 1981 goto out; 1982 1983 if (perf_stat_init_aggr_mode()) 1984 goto out; 1985 1986 /* 1987 * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless 1988 * while avoiding that older tools show confusing messages. 1989 * 1990 * However for pipe sessions we need to keep it zero, 1991 * because script's perf_evsel__check_attr is triggered 1992 * by attr->sample_type != 0, and we can't run it on 1993 * stat sessions. 1994 */ 1995 stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe); 1996 1997 /* 1998 * We dont want to block the signals - that would cause 1999 * child tasks to inherit that and Ctrl-C would not work. 2000 * What we want is for Ctrl-C to work in the exec()-ed 2001 * task, but being ignored by perf stat itself: 2002 */ 2003 atexit(sig_atexit); 2004 if (!forever) 2005 signal(SIGINT, skip_signal); 2006 signal(SIGCHLD, skip_signal); 2007 signal(SIGALRM, skip_signal); 2008 signal(SIGABRT, skip_signal); 2009 2010 status = 0; 2011 for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) { 2012 if (stat_config.run_count != 1 && verbose > 0) 2013 fprintf(output, "[ perf stat: executing run #%d ... ]\n", 2014 run_idx + 1); 2015 2016 if (run_idx != 0) 2017 perf_evlist__reset_prev_raw_counts(evsel_list); 2018 2019 status = run_perf_stat(argc, argv, run_idx); 2020 if (forever && status != -1 && !interval) { 2021 print_counters(NULL, argc, argv); 2022 perf_stat__reset_stats(); 2023 } 2024 } 2025 2026 if (!forever && status != -1 && !interval) 2027 print_counters(NULL, argc, argv); 2028 2029 if (STAT_RECORD) { 2030 /* 2031 * We synthesize the kernel mmap record just so that older tools 2032 * don't emit warnings about not being able to resolve symbols 2033 * due to /proc/sys/kernel/kptr_restrict settings and instear provide 2034 * a saner message about no samples being in the perf.data file. 2035 * 2036 * This also serves to suppress a warning about f_header.data.size == 0 2037 * in header.c at the moment 'perf stat record' gets introduced, which 2038 * is not really needed once we start adding the stat specific PERF_RECORD_ 2039 * records, but the need to suppress the kptr_restrict messages in older 2040 * tools remain -acme 2041 */ 2042 int fd = perf_data__fd(&perf_stat.data); 2043 int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat, 2044 process_synthesized_event, 2045 &perf_stat.session->machines.host); 2046 if (err) { 2047 pr_warning("Couldn't synthesize the kernel mmap record, harmless, " 2048 "older tools may produce warnings about this file\n."); 2049 } 2050 2051 if (!interval) { 2052 if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL)) 2053 pr_err("failed to write stat round event\n"); 2054 } 2055 2056 if (!perf_stat.data.is_pipe) { 2057 perf_stat.session->header.data_size += perf_stat.bytes_written; 2058 perf_session__write_header(perf_stat.session, evsel_list, fd, true); 2059 } 2060 2061 evlist__close(evsel_list); 2062 perf_session__delete(perf_stat.session); 2063 } 2064 2065 perf_stat__exit_aggr_mode(); 2066 perf_evlist__free_stats(evsel_list); 2067 out: 2068 zfree(&stat_config.walltime_run); 2069 2070 if (smi_cost && smi_reset) 2071 sysfs__write_int(FREEZE_ON_SMI_PATH, 0); 2072 2073 evlist__delete(evsel_list); 2074 2075 runtime_stat_delete(&stat_config); 2076 2077 return status; 2078 } 2079