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 if (transaction_run) { 1311 /* Handle -T as -M transaction. Once platform specific metrics 1312 * support has been added to the json files, all archictures 1313 * will use this approach. To determine transaction support 1314 * on an architecture test for such a metric name. 1315 */ 1316 if (metricgroup__has_metric("transaction")) { 1317 struct option opt = { .value = &evsel_list }; 1318 1319 return metricgroup__parse_groups(&opt, "transaction", 1320 &stat_config.metric_events); 1321 } 1322 1323 if (pmu_have_event("cpu", "cycles-ct") && 1324 pmu_have_event("cpu", "el-start")) 1325 err = parse_events(evsel_list, transaction_attrs, 1326 &errinfo); 1327 else 1328 err = parse_events(evsel_list, 1329 transaction_limited_attrs, 1330 &errinfo); 1331 if (err) { 1332 fprintf(stderr, "Cannot set up transaction events\n"); 1333 parse_events_print_error(&errinfo, transaction_attrs); 1334 return -1; 1335 } 1336 return 0; 1337 } 1338 1339 if (smi_cost) { 1340 int smi; 1341 1342 if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) { 1343 fprintf(stderr, "freeze_on_smi is not supported.\n"); 1344 return -1; 1345 } 1346 1347 if (!smi) { 1348 if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) { 1349 fprintf(stderr, "Failed to set freeze_on_smi.\n"); 1350 return -1; 1351 } 1352 smi_reset = true; 1353 } 1354 1355 if (pmu_have_event("msr", "aperf") && 1356 pmu_have_event("msr", "smi")) { 1357 if (!force_metric_only) 1358 stat_config.metric_only = true; 1359 err = parse_events(evsel_list, smi_cost_attrs, &errinfo); 1360 } else { 1361 fprintf(stderr, "To measure SMI cost, it needs " 1362 "msr/aperf/, msr/smi/ and cpu/cycles/ support\n"); 1363 parse_events_print_error(&errinfo, smi_cost_attrs); 1364 return -1; 1365 } 1366 if (err) { 1367 fprintf(stderr, "Cannot set up SMI cost events\n"); 1368 return -1; 1369 } 1370 return 0; 1371 } 1372 1373 if (topdown_run) { 1374 char *str = NULL; 1375 bool warn = false; 1376 1377 if (stat_config.aggr_mode != AGGR_GLOBAL && 1378 stat_config.aggr_mode != AGGR_CORE) { 1379 pr_err("top down event configuration requires --per-core mode\n"); 1380 return -1; 1381 } 1382 stat_config.aggr_mode = AGGR_CORE; 1383 if (nr_cgroups || !target__has_cpu(&target)) { 1384 pr_err("top down event configuration requires system-wide mode (-a)\n"); 1385 return -1; 1386 } 1387 1388 if (!force_metric_only) 1389 stat_config.metric_only = true; 1390 if (topdown_filter_events(topdown_attrs, &str, 1391 arch_topdown_check_group(&warn)) < 0) { 1392 pr_err("Out of memory\n"); 1393 return -1; 1394 } 1395 if (topdown_attrs[0] && str) { 1396 if (warn) 1397 arch_topdown_group_warn(); 1398 err = parse_events(evsel_list, str, &errinfo); 1399 if (err) { 1400 fprintf(stderr, 1401 "Cannot set up top down events %s: %d\n", 1402 str, err); 1403 parse_events_print_error(&errinfo, str); 1404 free(str); 1405 return -1; 1406 } 1407 } else { 1408 fprintf(stderr, "System does not support topdown\n"); 1409 return -1; 1410 } 1411 free(str); 1412 } 1413 1414 if (!evsel_list->core.nr_entries) { 1415 if (target__has_cpu(&target)) 1416 default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK; 1417 1418 if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0) 1419 return -1; 1420 if (pmu_have_event("cpu", "stalled-cycles-frontend")) { 1421 if (perf_evlist__add_default_attrs(evsel_list, 1422 frontend_attrs) < 0) 1423 return -1; 1424 } 1425 if (pmu_have_event("cpu", "stalled-cycles-backend")) { 1426 if (perf_evlist__add_default_attrs(evsel_list, 1427 backend_attrs) < 0) 1428 return -1; 1429 } 1430 if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0) 1431 return -1; 1432 } 1433 1434 /* Detailed events get appended to the event list: */ 1435 1436 if (detailed_run < 1) 1437 return 0; 1438 1439 /* Append detailed run extra attributes: */ 1440 if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 1441 return -1; 1442 1443 if (detailed_run < 2) 1444 return 0; 1445 1446 /* Append very detailed run extra attributes: */ 1447 if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 1448 return -1; 1449 1450 if (detailed_run < 3) 1451 return 0; 1452 1453 /* Append very, very detailed run extra attributes: */ 1454 return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 1455 } 1456 1457 static const char * const stat_record_usage[] = { 1458 "perf stat record [<options>]", 1459 NULL, 1460 }; 1461 1462 static void init_features(struct perf_session *session) 1463 { 1464 int feat; 1465 1466 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++) 1467 perf_header__set_feat(&session->header, feat); 1468 1469 perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT); 1470 perf_header__clear_feat(&session->header, HEADER_BUILD_ID); 1471 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA); 1472 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK); 1473 perf_header__clear_feat(&session->header, HEADER_AUXTRACE); 1474 } 1475 1476 static int __cmd_record(int argc, const char **argv) 1477 { 1478 struct perf_session *session; 1479 struct perf_data *data = &perf_stat.data; 1480 1481 argc = parse_options(argc, argv, stat_options, stat_record_usage, 1482 PARSE_OPT_STOP_AT_NON_OPTION); 1483 1484 if (output_name) 1485 data->path = output_name; 1486 1487 if (stat_config.run_count != 1 || forever) { 1488 pr_err("Cannot use -r option with perf stat record.\n"); 1489 return -1; 1490 } 1491 1492 session = perf_session__new(data, false, NULL); 1493 if (IS_ERR(session)) { 1494 pr_err("Perf session creation failed\n"); 1495 return PTR_ERR(session); 1496 } 1497 1498 init_features(session); 1499 1500 session->evlist = evsel_list; 1501 perf_stat.session = session; 1502 perf_stat.record = true; 1503 return argc; 1504 } 1505 1506 static int process_stat_round_event(struct perf_session *session, 1507 union perf_event *event) 1508 { 1509 struct perf_record_stat_round *stat_round = &event->stat_round; 1510 struct evsel *counter; 1511 struct timespec tsh, *ts = NULL; 1512 const char **argv = session->header.env.cmdline_argv; 1513 int argc = session->header.env.nr_cmdline; 1514 1515 evlist__for_each_entry(evsel_list, counter) 1516 perf_stat_process_counter(&stat_config, counter); 1517 1518 if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL) 1519 update_stats(&walltime_nsecs_stats, stat_round->time); 1520 1521 if (stat_config.interval && stat_round->time) { 1522 tsh.tv_sec = stat_round->time / NSEC_PER_SEC; 1523 tsh.tv_nsec = stat_round->time % NSEC_PER_SEC; 1524 ts = &tsh; 1525 } 1526 1527 print_counters(ts, argc, argv); 1528 return 0; 1529 } 1530 1531 static 1532 int process_stat_config_event(struct perf_session *session, 1533 union perf_event *event) 1534 { 1535 struct perf_tool *tool = session->tool; 1536 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1537 1538 perf_event__read_stat_config(&stat_config, &event->stat_config); 1539 1540 if (perf_cpu_map__empty(st->cpus)) { 1541 if (st->aggr_mode != AGGR_UNSET) 1542 pr_warning("warning: processing task data, aggregation mode not set\n"); 1543 return 0; 1544 } 1545 1546 if (st->aggr_mode != AGGR_UNSET) 1547 stat_config.aggr_mode = st->aggr_mode; 1548 1549 if (perf_stat.data.is_pipe) 1550 perf_stat_init_aggr_mode(); 1551 else 1552 perf_stat_init_aggr_mode_file(st); 1553 1554 return 0; 1555 } 1556 1557 static int set_maps(struct perf_stat *st) 1558 { 1559 if (!st->cpus || !st->threads) 1560 return 0; 1561 1562 if (WARN_ONCE(st->maps_allocated, "stats double allocation\n")) 1563 return -EINVAL; 1564 1565 perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads); 1566 1567 if (perf_evlist__alloc_stats(evsel_list, true)) 1568 return -ENOMEM; 1569 1570 st->maps_allocated = true; 1571 return 0; 1572 } 1573 1574 static 1575 int process_thread_map_event(struct perf_session *session, 1576 union perf_event *event) 1577 { 1578 struct perf_tool *tool = session->tool; 1579 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1580 1581 if (st->threads) { 1582 pr_warning("Extra thread map event, ignoring.\n"); 1583 return 0; 1584 } 1585 1586 st->threads = thread_map__new_event(&event->thread_map); 1587 if (!st->threads) 1588 return -ENOMEM; 1589 1590 return set_maps(st); 1591 } 1592 1593 static 1594 int process_cpu_map_event(struct perf_session *session, 1595 union perf_event *event) 1596 { 1597 struct perf_tool *tool = session->tool; 1598 struct perf_stat *st = container_of(tool, struct perf_stat, tool); 1599 struct perf_cpu_map *cpus; 1600 1601 if (st->cpus) { 1602 pr_warning("Extra cpu map event, ignoring.\n"); 1603 return 0; 1604 } 1605 1606 cpus = cpu_map__new_data(&event->cpu_map.data); 1607 if (!cpus) 1608 return -ENOMEM; 1609 1610 st->cpus = cpus; 1611 return set_maps(st); 1612 } 1613 1614 static int runtime_stat_new(struct perf_stat_config *config, int nthreads) 1615 { 1616 int i; 1617 1618 config->stats = calloc(nthreads, sizeof(struct runtime_stat)); 1619 if (!config->stats) 1620 return -1; 1621 1622 config->stats_num = nthreads; 1623 1624 for (i = 0; i < nthreads; i++) 1625 runtime_stat__init(&config->stats[i]); 1626 1627 return 0; 1628 } 1629 1630 static void runtime_stat_delete(struct perf_stat_config *config) 1631 { 1632 int i; 1633 1634 if (!config->stats) 1635 return; 1636 1637 for (i = 0; i < config->stats_num; i++) 1638 runtime_stat__exit(&config->stats[i]); 1639 1640 zfree(&config->stats); 1641 } 1642 1643 static const char * const stat_report_usage[] = { 1644 "perf stat report [<options>]", 1645 NULL, 1646 }; 1647 1648 static struct perf_stat perf_stat = { 1649 .tool = { 1650 .attr = perf_event__process_attr, 1651 .event_update = perf_event__process_event_update, 1652 .thread_map = process_thread_map_event, 1653 .cpu_map = process_cpu_map_event, 1654 .stat_config = process_stat_config_event, 1655 .stat = perf_event__process_stat_event, 1656 .stat_round = process_stat_round_event, 1657 }, 1658 .aggr_mode = AGGR_UNSET, 1659 }; 1660 1661 static int __cmd_report(int argc, const char **argv) 1662 { 1663 struct perf_session *session; 1664 const struct option options[] = { 1665 OPT_STRING('i', "input", &input_name, "file", "input file name"), 1666 OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode, 1667 "aggregate counts per processor socket", AGGR_SOCKET), 1668 OPT_SET_UINT(0, "per-die", &perf_stat.aggr_mode, 1669 "aggregate counts per processor die", AGGR_DIE), 1670 OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode, 1671 "aggregate counts per physical processor core", AGGR_CORE), 1672 OPT_SET_UINT(0, "per-node", &perf_stat.aggr_mode, 1673 "aggregate counts per numa node", AGGR_NODE), 1674 OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode, 1675 "disable CPU count aggregation", AGGR_NONE), 1676 OPT_END() 1677 }; 1678 struct stat st; 1679 int ret; 1680 1681 argc = parse_options(argc, argv, options, stat_report_usage, 0); 1682 1683 if (!input_name || !strlen(input_name)) { 1684 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) 1685 input_name = "-"; 1686 else 1687 input_name = "perf.data"; 1688 } 1689 1690 perf_stat.data.path = input_name; 1691 perf_stat.data.mode = PERF_DATA_MODE_READ; 1692 1693 session = perf_session__new(&perf_stat.data, false, &perf_stat.tool); 1694 if (IS_ERR(session)) 1695 return PTR_ERR(session); 1696 1697 perf_stat.session = session; 1698 stat_config.output = stderr; 1699 evsel_list = session->evlist; 1700 1701 ret = perf_session__process_events(session); 1702 if (ret) 1703 return ret; 1704 1705 perf_session__delete(session); 1706 return 0; 1707 } 1708 1709 static void setup_system_wide(int forks) 1710 { 1711 /* 1712 * Make system wide (-a) the default target if 1713 * no target was specified and one of following 1714 * conditions is met: 1715 * 1716 * - there's no workload specified 1717 * - there is workload specified but all requested 1718 * events are system wide events 1719 */ 1720 if (!target__none(&target)) 1721 return; 1722 1723 if (!forks) 1724 target.system_wide = true; 1725 else { 1726 struct evsel *counter; 1727 1728 evlist__for_each_entry(evsel_list, counter) { 1729 if (!counter->core.system_wide) 1730 return; 1731 } 1732 1733 if (evsel_list->core.nr_entries) 1734 target.system_wide = true; 1735 } 1736 } 1737 1738 int cmd_stat(int argc, const char **argv) 1739 { 1740 const char * const stat_usage[] = { 1741 "perf stat [<options>] [<command>]", 1742 NULL 1743 }; 1744 int status = -EINVAL, run_idx; 1745 const char *mode; 1746 FILE *output = stderr; 1747 unsigned int interval, timeout; 1748 const char * const stat_subcommands[] = { "record", "report" }; 1749 1750 setlocale(LC_ALL, ""); 1751 1752 evsel_list = evlist__new(); 1753 if (evsel_list == NULL) 1754 return -ENOMEM; 1755 1756 parse_events__shrink_config_terms(); 1757 1758 /* String-parsing callback-based options would segfault when negated */ 1759 set_option_flag(stat_options, 'e', "event", PARSE_OPT_NONEG); 1760 set_option_flag(stat_options, 'M', "metrics", PARSE_OPT_NONEG); 1761 set_option_flag(stat_options, 'G', "cgroup", PARSE_OPT_NONEG); 1762 1763 argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands, 1764 (const char **) stat_usage, 1765 PARSE_OPT_STOP_AT_NON_OPTION); 1766 perf_stat__collect_metric_expr(evsel_list); 1767 perf_stat__init_shadow_stats(); 1768 1769 if (stat_config.csv_sep) { 1770 stat_config.csv_output = true; 1771 if (!strcmp(stat_config.csv_sep, "\\t")) 1772 stat_config.csv_sep = "\t"; 1773 } else 1774 stat_config.csv_sep = DEFAULT_SEPARATOR; 1775 1776 if (argc && !strncmp(argv[0], "rec", 3)) { 1777 argc = __cmd_record(argc, argv); 1778 if (argc < 0) 1779 return -1; 1780 } else if (argc && !strncmp(argv[0], "rep", 3)) 1781 return __cmd_report(argc, argv); 1782 1783 interval = stat_config.interval; 1784 timeout = stat_config.timeout; 1785 1786 /* 1787 * For record command the -o is already taken care of. 1788 */ 1789 if (!STAT_RECORD && output_name && strcmp(output_name, "-")) 1790 output = NULL; 1791 1792 if (output_name && output_fd) { 1793 fprintf(stderr, "cannot use both --output and --log-fd\n"); 1794 parse_options_usage(stat_usage, stat_options, "o", 1); 1795 parse_options_usage(NULL, stat_options, "log-fd", 0); 1796 goto out; 1797 } 1798 1799 if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) { 1800 fprintf(stderr, "--metric-only is not supported with --per-thread\n"); 1801 goto out; 1802 } 1803 1804 if (stat_config.metric_only && stat_config.run_count > 1) { 1805 fprintf(stderr, "--metric-only is not supported with -r\n"); 1806 goto out; 1807 } 1808 1809 if (stat_config.walltime_run_table && stat_config.run_count <= 1) { 1810 fprintf(stderr, "--table is only supported with -r\n"); 1811 parse_options_usage(stat_usage, stat_options, "r", 1); 1812 parse_options_usage(NULL, stat_options, "table", 0); 1813 goto out; 1814 } 1815 1816 if (output_fd < 0) { 1817 fprintf(stderr, "argument to --log-fd must be a > 0\n"); 1818 parse_options_usage(stat_usage, stat_options, "log-fd", 0); 1819 goto out; 1820 } 1821 1822 if (!output) { 1823 struct timespec tm; 1824 mode = append_file ? "a" : "w"; 1825 1826 output = fopen(output_name, mode); 1827 if (!output) { 1828 perror("failed to create output file"); 1829 return -1; 1830 } 1831 clock_gettime(CLOCK_REALTIME, &tm); 1832 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 1833 } else if (output_fd > 0) { 1834 mode = append_file ? "a" : "w"; 1835 output = fdopen(output_fd, mode); 1836 if (!output) { 1837 perror("Failed opening logfd"); 1838 return -errno; 1839 } 1840 } 1841 1842 stat_config.output = output; 1843 1844 /* 1845 * let the spreadsheet do the pretty-printing 1846 */ 1847 if (stat_config.csv_output) { 1848 /* User explicitly passed -B? */ 1849 if (big_num_opt == 1) { 1850 fprintf(stderr, "-B option not supported with -x\n"); 1851 parse_options_usage(stat_usage, stat_options, "B", 1); 1852 parse_options_usage(NULL, stat_options, "x", 1); 1853 goto out; 1854 } else /* Nope, so disable big number formatting */ 1855 stat_config.big_num = false; 1856 } else if (big_num_opt == 0) /* User passed --no-big-num */ 1857 stat_config.big_num = false; 1858 1859 setup_system_wide(argc); 1860 1861 /* 1862 * Display user/system times only for single 1863 * run and when there's specified tracee. 1864 */ 1865 if ((stat_config.run_count == 1) && target__none(&target)) 1866 stat_config.ru_display = true; 1867 1868 if (stat_config.run_count < 0) { 1869 pr_err("Run count must be a positive number\n"); 1870 parse_options_usage(stat_usage, stat_options, "r", 1); 1871 goto out; 1872 } else if (stat_config.run_count == 0) { 1873 forever = true; 1874 stat_config.run_count = 1; 1875 } 1876 1877 if (stat_config.walltime_run_table) { 1878 stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0])); 1879 if (!stat_config.walltime_run) { 1880 pr_err("failed to setup -r option"); 1881 goto out; 1882 } 1883 } 1884 1885 if ((stat_config.aggr_mode == AGGR_THREAD) && 1886 !target__has_task(&target)) { 1887 if (!target.system_wide || target.cpu_list) { 1888 fprintf(stderr, "The --per-thread option is only " 1889 "available when monitoring via -p -t -a " 1890 "options or only --per-thread.\n"); 1891 parse_options_usage(NULL, stat_options, "p", 1); 1892 parse_options_usage(NULL, stat_options, "t", 1); 1893 goto out; 1894 } 1895 } 1896 1897 /* 1898 * no_aggr, cgroup are for system-wide only 1899 * --per-thread is aggregated per thread, we dont mix it with cpu mode 1900 */ 1901 if (((stat_config.aggr_mode != AGGR_GLOBAL && 1902 stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) && 1903 !target__has_cpu(&target)) { 1904 fprintf(stderr, "both cgroup and no-aggregation " 1905 "modes only available in system-wide mode\n"); 1906 1907 parse_options_usage(stat_usage, stat_options, "G", 1); 1908 parse_options_usage(NULL, stat_options, "A", 1); 1909 parse_options_usage(NULL, stat_options, "a", 1); 1910 goto out; 1911 } 1912 1913 if (add_default_attributes()) 1914 goto out; 1915 1916 target__validate(&target); 1917 1918 if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide)) 1919 target.per_thread = true; 1920 1921 if (perf_evlist__create_maps(evsel_list, &target) < 0) { 1922 if (target__has_task(&target)) { 1923 pr_err("Problems finding threads of monitor\n"); 1924 parse_options_usage(stat_usage, stat_options, "p", 1); 1925 parse_options_usage(NULL, stat_options, "t", 1); 1926 } else if (target__has_cpu(&target)) { 1927 perror("failed to parse CPUs map"); 1928 parse_options_usage(stat_usage, stat_options, "C", 1); 1929 parse_options_usage(NULL, stat_options, "a", 1); 1930 } 1931 goto out; 1932 } 1933 1934 /* 1935 * Initialize thread_map with comm names, 1936 * so we could print it out on output. 1937 */ 1938 if (stat_config.aggr_mode == AGGR_THREAD) { 1939 thread_map__read_comms(evsel_list->core.threads); 1940 if (target.system_wide) { 1941 if (runtime_stat_new(&stat_config, 1942 perf_thread_map__nr(evsel_list->core.threads))) { 1943 goto out; 1944 } 1945 } 1946 } 1947 1948 if (stat_config.aggr_mode == AGGR_NODE) 1949 cpu__setup_cpunode_map(); 1950 1951 if (stat_config.times && interval) 1952 interval_count = true; 1953 else if (stat_config.times && !interval) { 1954 pr_err("interval-count option should be used together with " 1955 "interval-print.\n"); 1956 parse_options_usage(stat_usage, stat_options, "interval-count", 0); 1957 parse_options_usage(stat_usage, stat_options, "I", 1); 1958 goto out; 1959 } 1960 1961 if (timeout && timeout < 100) { 1962 if (timeout < 10) { 1963 pr_err("timeout must be >= 10ms.\n"); 1964 parse_options_usage(stat_usage, stat_options, "timeout", 0); 1965 goto out; 1966 } else 1967 pr_warning("timeout < 100ms. " 1968 "The overhead percentage could be high in some cases. " 1969 "Please proceed with caution.\n"); 1970 } 1971 if (timeout && interval) { 1972 pr_err("timeout option is not supported with interval-print.\n"); 1973 parse_options_usage(stat_usage, stat_options, "timeout", 0); 1974 parse_options_usage(stat_usage, stat_options, "I", 1); 1975 goto out; 1976 } 1977 1978 if (perf_evlist__alloc_stats(evsel_list, interval)) 1979 goto out; 1980 1981 if (perf_stat_init_aggr_mode()) 1982 goto out; 1983 1984 /* 1985 * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless 1986 * while avoiding that older tools show confusing messages. 1987 * 1988 * However for pipe sessions we need to keep it zero, 1989 * because script's perf_evsel__check_attr is triggered 1990 * by attr->sample_type != 0, and we can't run it on 1991 * stat sessions. 1992 */ 1993 stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe); 1994 1995 /* 1996 * We dont want to block the signals - that would cause 1997 * child tasks to inherit that and Ctrl-C would not work. 1998 * What we want is for Ctrl-C to work in the exec()-ed 1999 * task, but being ignored by perf stat itself: 2000 */ 2001 atexit(sig_atexit); 2002 if (!forever) 2003 signal(SIGINT, skip_signal); 2004 signal(SIGCHLD, skip_signal); 2005 signal(SIGALRM, skip_signal); 2006 signal(SIGABRT, skip_signal); 2007 2008 status = 0; 2009 for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) { 2010 if (stat_config.run_count != 1 && verbose > 0) 2011 fprintf(output, "[ perf stat: executing run #%d ... ]\n", 2012 run_idx + 1); 2013 2014 if (run_idx != 0) 2015 perf_evlist__reset_prev_raw_counts(evsel_list); 2016 2017 status = run_perf_stat(argc, argv, run_idx); 2018 if (forever && status != -1 && !interval) { 2019 print_counters(NULL, argc, argv); 2020 perf_stat__reset_stats(); 2021 } 2022 } 2023 2024 if (!forever && status != -1 && !interval) 2025 print_counters(NULL, argc, argv); 2026 2027 if (STAT_RECORD) { 2028 /* 2029 * We synthesize the kernel mmap record just so that older tools 2030 * don't emit warnings about not being able to resolve symbols 2031 * due to /proc/sys/kernel/kptr_restrict settings and instear provide 2032 * a saner message about no samples being in the perf.data file. 2033 * 2034 * This also serves to suppress a warning about f_header.data.size == 0 2035 * in header.c at the moment 'perf stat record' gets introduced, which 2036 * is not really needed once we start adding the stat specific PERF_RECORD_ 2037 * records, but the need to suppress the kptr_restrict messages in older 2038 * tools remain -acme 2039 */ 2040 int fd = perf_data__fd(&perf_stat.data); 2041 int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat, 2042 process_synthesized_event, 2043 &perf_stat.session->machines.host); 2044 if (err) { 2045 pr_warning("Couldn't synthesize the kernel mmap record, harmless, " 2046 "older tools may produce warnings about this file\n."); 2047 } 2048 2049 if (!interval) { 2050 if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL)) 2051 pr_err("failed to write stat round event\n"); 2052 } 2053 2054 if (!perf_stat.data.is_pipe) { 2055 perf_stat.session->header.data_size += perf_stat.bytes_written; 2056 perf_session__write_header(perf_stat.session, evsel_list, fd, true); 2057 } 2058 2059 evlist__close(evsel_list); 2060 perf_session__delete(perf_stat.session); 2061 } 2062 2063 perf_stat__exit_aggr_mode(); 2064 perf_evlist__free_stats(evsel_list); 2065 out: 2066 zfree(&stat_config.walltime_run); 2067 2068 if (smi_cost && smi_reset) 2069 sysfs__write_int(FREEZE_ON_SMI_PATH, 0); 2070 2071 evlist__delete(evsel_list); 2072 2073 runtime_stat_delete(&stat_config); 2074 2075 return status; 2076 } 2077